@node-core/utils 7.2.1 → 7.2.2

package/lib/ci/build-types/normal_build.js

@@ -76,7 +76,7 @@ export class NormalBuild extends Job {
       if (!upstream) {
         return true;
       } else {
-        return this.jobUrl.includes(upstream + '');
+        return this.jobUrl.endsWith(`/${upstream}/`);
       }
     });
 

package/lib/ci/build-types/pr_build.js

@@ -1,4 +1,5 @@
 import { PR_TREE } from '../jenkins_constants.js';
+import { statusType } from '../ci_utils.js';
 import CIFailureParser from '../ci_failure_parser.js';
 import { TestBuild } from './test_build.js';
 import { CommitBuild } from './commit_build.js';
@@ -69,7 +70,7 @@ export class PRBuild extends TestBuild {
 
     // Get result from the sub build
     // assert.strictEqual(commitBuild.jobName, 'node-test-commit');
-    const allBuilds = commitBuild.build.subBuilds;
+    const allBuilds = commitBuild.build?.subBuilds;
     // TODO: fetch result, builtOn, timestamp in the commit build's own data
     // ..or maybe they do not worth an additional API call?
     // Note that we have to pass the actions down to detect resume builds.
@@ -78,6 +79,15 @@ export class PRBuild extends TestBuild {
     };
     const commitBuildId = commitBuild.buildNumber;
     this.commitBuild = new CommitBuild(cli, request, commitBuildId, this.skipMoreThan);
+    // Jenkins can retain the result after the nested build is no longer available.
+    if (!commitBuild.build) {
+      this.commitBuild.setBuildData(buildData);
+      this.failures = result === statusType.SUCCESS
+        ? []
+        : [new NCUFailure({ url: this.commitBuild.jobUrl }, 'Build data is unavailable')];
+      this.commitBuild.failures = this.failures;
+      return { result, builds: this.builds, failures: this.failures };
+    }
     const { builds, failures } = await this.commitBuild.getResults(buildData);
 
     // Set up aliases for display

package/lib/ci/build-types/test_run.js

@@ -31,7 +31,7 @@ export class TestRun extends Job {
       ];
       return this.failures;
     }
-    this.causes = this.getCause(data.actions) || {};
+    this.cause = this.getCause(data.actions) || {};
     this.builtOn = data.builtOn;
   }
 

package/lib/cli.js

@@ -1,5 +1,5 @@
-import ora from 'ora';
 import { styleText } from 'node:util';
+import yoctoSpinner from 'yocto-spinner';
 import * as inquirer from '@inquirer/prompts';
 
 import { warning, error, info, success } from './figures.js';
@@ -29,7 +29,7 @@ export default class CLI {
   constructor(stream, options = {}) {
     const spinnerOptions = options.spinner ?? {};
     this.stream = stream || process.stderr;
-    this.spinner = ora({ stream: this.stream, ...spinnerOptions });
+    this.spinner = yoctoSpinner({ stream: this.stream, ...spinnerOptions });
     this.SPINNER_STATUS = SPINNER_STATUS;
     this.QUESTION_TYPE = QUESTION_TYPE;
     this.figureIndent = '   ';
@@ -154,10 +154,7 @@ export default class CLI {
       case INFO:
         symbol = info;
     }
-    const text = ' ' + rawText;
-    this.spinner.stopAndPersist({
-      symbol, text
-    });
+    this.spinner.stop(`${symbol}  ${rawText}`);
   }
 
   write(text) {

package/lib/links.js

@@ -1,4 +1,4 @@
-import * as cheerio from 'cheerio';
+import { Parser } from 'htmlparser2';
 
 const FIXES_RE = /(Close[ds]?|Fix(e[ds])?|Resolve[sd]?)\s*:\s*(\S+)/mgi;
 const FIX_RE = /(Close[ds]?|Fix(e[ds])?|Resolve[sd]?)\s*:\s*(\S+)/i;
@@ -13,7 +13,26 @@ export class LinkParser {
   constructor(owner, repo, html) {
     this.owner = owner;
     this.repo = repo;
-    this.$ = cheerio.load(html);
+    this.text = '';
+    this.links = [];
+
+    let currentLink;
+    const parser = new Parser({
+      onopentag: (name, attributes) => {
+        if (name === 'a') {
+          currentLink = { href: attributes.href, text: '' };
+          this.links.push(currentLink);
+        }
+      },
+      ontext: (text) => {
+        this.text += text;
+        if (currentLink) currentLink.text += text;
+      },
+      onclosetag: (name) => {
+        if (name === 'a') currentLink = undefined;
+      }
+    });
+    parser.end(html);
   }
 
   getFixesUrlsFromArray(arr) {
@@ -55,32 +74,25 @@ export class LinkParser {
   // Do this so we can reliably get the correct url.
   // Otherwise, the number could reference a PR or an issue.
   getUrlFromOP(ref) {
-    const as = this.$('a');
-    const links = as.map((i, el) => this.$(el)).get();
-    for (const link of links) {
-      const text = link.text();
-      if (text === ref) {
-        const href = link.attr('href');
-        if (href) return href;
+    for (const link of this.links) {
+      if (link.text === ref) {
+        if (link.href) return link.href;
       }
     }
   }
 
   getFixes() {
-    const text = this.$.text();
-    const fixes = text.match(FIXES_RE) || [];
+    const fixes = this.text.match(FIXES_RE) || [];
     return this.getFixesUrlsFromArray(fixes);
   }
 
   getRefs() {
-    const text = this.$.text();
-    const refs = text.match(REFS_RE) || [];
+    const refs = this.text.match(REFS_RE) || [];
     return this.getRefsUrlsFromArray(refs);
   }
 
   getAltPrUrl() {
-    const text = this.$.text();
-    const refs = text.match(PR_RE) || [];
+    const refs = this.text.match(PR_RE) || [];
     return this.getPRUrlsFromArray(refs);
   }
 }

package/lib/pr_checker.js

@@ -467,43 +467,54 @@ export default class PRChecker {
       }
 
       if (!GITHUB_SUCCESS_CONCLUSIONS.includes(conclusion)) {
-        hasFailures = true;
+        const runs = checkRuns?.nodes ?? [];
+        const allRunsSkipped = runs.length > 0 &&
+          runs.length === checkRuns.totalCount &&
+          runs.every((checkRun) => checkRun.status === 'COMPLETED' &&
+            checkRun.conclusion === 'SKIPPED');
+
+        // GitHub can report a STARTUP_FAILURE for a workflow even though all
+        // of its conditional jobs were skipped. There is no failed check in
+        // that case, so the suite should not make the commit unlandable.
+        if (conclusion === 'STARTUP_FAILURE' && allRunsSkipped) {
+          continue;
+        }
 
-        // If we have detailed checkRuns, show specific failing jobs
-        if (checkRuns && checkRuns.nodes && checkRuns.nodes.length > 0) {
-          for (const checkRun of checkRuns.nodes) {
-            if (checkRun.status === 'COMPLETED' &&
-                !GITHUB_SUCCESS_CONCLUSIONS.includes(checkRun.conclusion)) {
-              if (checkRun.conclusion === 'CANCELLED') {
-                cancelledJobs.push({
-                  name: checkRun.name,
-                  conclusion: checkRun.conclusion,
-                  url: checkRun.detailsUrl
-                });
-              } else {
-                failedJobs.push({
-                  name: checkRun.name,
-                  conclusion: checkRun.conclusion,
-                  url: checkRun.detailsUrl
-                });
-              }
+        hasFailures = true;
+        let reportedFailure = false;
+
+        // If we have detailed checkRuns, show specific failing jobs.
+        for (const checkRun of runs) {
+          if (checkRun.status === 'COMPLETED' &&
+              !GITHUB_SUCCESS_CONCLUSIONS.includes(checkRun.conclusion)) {
+            reportedFailure = true;
+            if (checkRun.conclusion === 'CANCELLED') {
+              cancelledJobs.push({
+                name: checkRun.name,
+                conclusion: checkRun.conclusion,
+                url: checkRun.detailsUrl
+              });
+            } else {
+              failedJobs.push({
+                name: checkRun.name,
+                conclusion: checkRun.conclusion,
+                url: checkRun.detailsUrl
+              });
             }
           }
-        } else {
-          // Fallback to check suite level information if no checkRuns
-          if (conclusion === 'CANCELLED') {
-            cancelledJobs.push({
-              name: GITHUB_ACTIONS_APP,
-              conclusion,
-              url: null
-            });
-          } else {
-            failedJobs.push({
-              name: GITHUB_ACTIONS_APP,
-              conclusion,
-              url: null
-            });
-          }
+        }
+
+        // Fall back to the suite when its failed conclusion is not reflected
+        // by an individual check run.
+        if (!reportedFailure) {
+          const failures = conclusion === 'CANCELLED'
+            ? cancelledJobs
+            : failedJobs;
+          failures.push({
+            name: GITHUB_ACTIONS_APP,
+            conclusion,
+            url: null
+          });
         }
       }
     }

package/lib/queries/PR.gql

@@ -38,6 +38,7 @@ query PR($prid: Int!, $owner: String!, $repo: String!) {
                 conclusion,
                 status,
                 checkRuns(first: 40) {
+                  totalCount
                   nodes {
                     name
                     status

package/node_modules/htmlparser2/README.md

@@ -83,8 +83,37 @@ JS! Hooray!
 That's it?!
 ```
 
-This example only shows three of the possible events.
-Read more about the parser, its events and options in the [wiki](https://github.com/fb55/htmlparser2/wiki/Parser-options).
+### Parser events
+
+All callbacks are optional. The handler object you pass to `Parser` may implement any subset of these:
+
+| Event                                        | Description                                                                                                                                      |
+| -------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------ |
+| `onopentag(name, attribs, isImplied)`        | Opening tag. `attribs` is an object mapping attribute names to values. `isImplied` is `true` when the tag was opened implicitly (HTML mode only). |
+| `onopentagname(name)`                        | Emitted for the tag name as soon as it is available (before attributes are parsed).                                                              |
+| `onattribute(name, value, quote)`            | Attribute. `quote` is `"` / `'` / `null` (unquoted) / `undefined` (no value, e.g. `disabled`).                                                  |
+| `onclosetag(name, isImplied)`                | Closing tag. `isImplied` is `true` when the tag was closed implicitly (HTML mode only).                                                          |
+| `ontext(data)`                               | Text content. May fire multiple times for a single text node.                                                                                    |
+| `oncomment(data)`                            | Comment (content between `<!--` and `-->`).                                                                                                      |
+| `oncdatastart()`                             | Opening of a CDATA section (`<![CDATA[`).                                                                                                        |
+| `oncdataend()`                               | End of a CDATA section (`]]>`).                                                                                                                  |
+| `onprocessinginstruction(name, data)`        | Processing instruction (e.g. `<?xml ...?>`).                                                                                                     |
+| `oncommentend()`                             | Fires after a comment has ended.                                                                                                                 |
+| `onparserinit(parser)`                       | Fires when the parser is initialized or reset.                                                                                                   |
+| `onreset()`                                  | Fires when `parser.reset()` is called.                                                                                                           |
+| `onend()`                                    | Fires when parsing is complete.                                                                                                                  |
+| `onerror(error)`                             | Fires on error.                                                                                                                                  |
+
+### Parser options
+
+| Option                   | Type      | Default    | Description                                                                                                                                              |
+| ------------------------ | --------- | ---------- | -------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `xmlMode`                | `boolean` | `false`    | Treat the document as XML. This affects entity decoding, self-closing tags, CDATA handling, and more. Set this to `true` for XML, RSS, Atom and RDF feeds. |
+| `decodeEntities`         | `boolean` | `true`     | Decode HTML entities (e.g. `&amp;` -> `&`).                                                                                                              |
+| `lowerCaseTags`          | `boolean` | `!xmlMode` | Lowercase tag names.                                                                                                                                     |
+| `lowerCaseAttributeNames`| `boolean` | `!xmlMode` | Lowercase attribute names.                                                                                                                               |
+| `recognizeSelfClosing`   | `boolean` | `xmlMode`  | Recognize self-closing tags (e.g. `<br/>`). Always enabled in `xmlMode`.                                                                                 |
+| `recognizeCDATA`         | `boolean` | `xmlMode`  | Recognize CDATA sections as text. Always enabled in `xmlMode`.                                                                                           |
 
 ### Usage with streams
 
@@ -106,25 +135,100 @@ htmlStream.pipe(parserStream).on("finish", () => console.log("done"));
 
 ## Getting a DOM
 
-The `DomHandler` produces a DOM (document object model) that can be manipulated using the [`DomUtils`](https://github.com/fb55/DomUtils) helper.
+The `parseDocument` helper parses a string and returns a DOM tree (a [`Document`](https://github.com/fb55/domhandler) node).
 
 ```js
 import * as htmlparser2 from "htmlparser2";
 
-const dom = htmlparser2.parseDocument(htmlString);
+const dom = htmlparser2.parseDocument(
+    `<ul id="fruits">
+        <li class="apple">Apple</li>
+        <li class="orange">Orange</li>
+    </ul>`,
+);
+```
+
+`parseDocument` accepts an optional second argument with both parser and [DOM handler options](https://github.com/fb55/domhandler):
+
+```js
+const dom = htmlparser2.parseDocument(data, {
+    // Parser options
+    xmlMode: true,
+
+    // domhandler options
+    withStartIndices: true, // Add `startIndex` to each node
+    withEndIndices: true,   // Add `endIndex` to each node
+});
+```
+
+### Searching the DOM
+
+The [`DomUtils`](https://github.com/fb55/domutils) module (re-exported on the main `htmlparser2` export) provides helpers for finding nodes:
+
+```js
+import * as htmlparser2 from "htmlparser2";
+
+const dom = htmlparser2.parseDocument(`<div><p id="greeting">Hello</p></div>`);
+
+// Find elements by ID, tag name, or class
+const greeting = htmlparser2.DomUtils.getElementById("greeting", dom);
+const paragraphs = htmlparser2.DomUtils.getElementsByTagName("p", dom);
+
+// Find elements with custom test functions
+const all = htmlparser2.DomUtils.findAll(
+    (el) => el.attribs?.class === "active",
+    dom,
+);
+
+// Get text content
+htmlparser2.DomUtils.textContent(greeting); // "Hello"
+```
+
+For CSS selector queries, use [`css-select`](https://github.com/fb55/css-select):
+
+```js
+import { selectAll, selectOne } from "css-select";
+
+const results = selectAll("ul#fruits > li", dom);
+const first = selectOne("li.apple", dom);
+```
+
+Or, if you'd prefer a jQuery-like API, use [`cheerio`](https://github.com/cheeriojs/cheerio).
+
+### Modifying and serializing the DOM
+
+Use `DomUtils` to modify the tree, and [`dom-serializer`](https://github.com/cheeriojs/dom-serializer) (also available as `DomUtils.getOuterHTML`) to serialize it back to HTML:
+
+```js
+import * as htmlparser2 from "htmlparser2";
+
+const dom = htmlparser2.parseDocument(
+    `<ul><li>Apple</li><li>Orange</li></ul>`,
+);
+
+// Remove the first <li>
+const items = htmlparser2.DomUtils.getElementsByTagName("li", dom);
+htmlparser2.DomUtils.removeElement(items[0]);
+
+// Serialize back to HTML
+const html = htmlparser2.DomUtils.getOuterHTML(dom);
+// "<ul><li>Orange</li></ul>"
 ```
 
-The `DomHandler`, while still bundled with this module, was moved to its [own module](https://github.com/fb55/domhandler).
-Have a look at that for further information.
+Other manipulation helpers include `appendChild`, `prependChild`, `append`, `prepend`, and `replaceElement` -- see the [`domutils` docs](https://github.com/fb55/domutils) for the full API.
 
-## Parsing Feeds
+## Parsing feeds
 
 `htmlparser2` makes it easy to parse RSS, RDF and Atom feeds, by providing a `parseFeed` method:
 
 ```javascript
-const feed = htmlparser2.parseFeed(content, options);
+const feed = htmlparser2.parseFeed(content);
 ```
 
+This returns an object with `type`, `title`, `link`, `description`, `updated`, `author`, and `items` (an array of feed entries), or `null` if the document isn't a recognized feed format.
+
+The `xmlMode` option is enabled by default for `parseFeed`. If you pass custom options, make sure to include `xmlMode: true`.
+
 ## Performance
 
 After having some artificial benchmarks for some time, **@AndreasMadsen** published his [`htmlparser-benchmark`](https://github.com/AndreasMadsen/htmlparser-benchmark), which benchmarks HTML parses based on real-world websites.
@@ -147,25 +251,7 @@ saxes              : 45.7921 ms/file ± 128.691
 html5              : 120.844 ms/file ± 153.944
 ```
 
-## How does this module differ from [node-htmlparser](https://github.com/tautologistics/node-htmlparser)?
-
-In 2011, this module started as a fork of the `htmlparser` module.
-`htmlparser2` was rewritten multiple times and, while it maintains an API that's mostly compatible with `htmlparser`, the projects don't share any code anymore.
-
-The parser now provides a callback interface inspired by [sax.js](https://github.com/isaacs/sax-js) (originally targeted at [readabilitySAX](https://github.com/fb55/readabilitysax)).
-As a result, old handlers won't work anymore.
-
-The `DefaultHandler` was renamed to clarify its purpose (to `DomHandler`). The old name is still available when requiring `htmlparser2` and your code should work as expected.
-
-The `RssHandler` was replaced with a `getFeed` function that takes a `DomHandler` DOM and returns a feed object. There is a `parseFeed` helper function that can be used to parse a feed from a string.
-
 ## Security contact information
 
 To report a security vulnerability, please use the [Tidelift security contact](https://tidelift.com/security).
 Tidelift will coordinate the fix and disclosure.
-
-## `htmlparser2` for enterprise
-
-Available as part of the Tidelift Subscription.
-
-The maintainers of `htmlparser2` and thousands of other packages are working with Tidelift to deliver commercial support and maintenance for the open source dependencies you use to build your applications. Save time, reduce risk, and improve code health, while paying the maintainers of the exact dependencies you use. [Learn more.](https://tidelift.com/subscription/pkg/npm-htmlparser2?utm_source=npm-htmlparser2&utm_medium=referral&utm_campaign=enterprise&utm_term=repo)