@mui/internal-code-infra 0.0.4-canary.63 → 0.0.4-canary.65

package/build/eslint/mui/rules/no-floating-cleanup.d.mts

@@ -0,0 +1,5 @@
+import { ESLintUtils } from '@typescript-eslint/utils';
+declare const _default: ESLintUtils.RuleModule<"floatingCleanup", [], unknown, ESLintUtils.RuleListener> & {
+    name: string;
+};
+export default _default;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mui/internal-code-infra",
-  "version": "0.0.4-canary.63",
+  "version": "0.0.4-canary.65",
   "author": "MUI Team",
   "description": "Infra scripts and configs to be used across MUI repos.",
   "license": "MIT",
@@ -192,7 +192,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitSha": "e08081fbb9ce12311a1acb555f69108dc1231951",
+  "gitSha": "308d63cc49db1419769226ebad3e2ceec1dd49d2",
   "scripts": {
     "build": "tsgo -p tsconfig.build.json",
     "typescript": "tsgo -noEmit",

package/src/brokenLinksChecker/index.mjs

@@ -9,6 +9,7 @@ import { Transform } from 'node:stream';
 import { Worker } from 'node:worker_threads';
 
 const DEFAULT_CONCURRENCY = 4;
+const SERVER_START_TIMEOUT = 10000;
 
 const crawlWorkerUrl = new URL('./crawlWorker.mjs', import.meta.url);
 
@@ -620,30 +621,56 @@ export async function crawl(rawOptions) {
 
   /** @type {AbortController | null} */
   let controller = null;
-  if (options.startCommand) {
-    console.log(chalk.blue(`Starting server with "${options.startCommand}"...`));
-    controller = new AbortController();
-    const appProcess = execaCommand(options.startCommand, {
-      stdout: 'pipe',
-      stderr: 'pipe',
-      cancelSignal: controller.signal,
-      env: {
-        FORCE_COLOR: '1',
-        ...process.env,
-      },
-    });
 
-    // Prefix server logs
-    const serverPrefix = chalk.gray('server: ');
-    appProcess.stdout.pipe(prefixLines(serverPrefix)).pipe(process.stdout);
-    appProcess.stderr.pipe(prefixLines(serverPrefix)).pipe(process.stderr);
-    appProcess.catch(() => {});
+  try {
+    if (options.startCommand) {
+      console.log(chalk.blue(`Starting server with "${options.startCommand}"...`));
+      controller = new AbortController();
+      const appProcess = execaCommand(options.startCommand, {
+        stdout: 'pipe',
+        stderr: 'pipe',
+        cancelSignal: controller.signal,
+        env: {
+          FORCE_COLOR: '1',
+          ...process.env,
+        },
+      });
+
+      // Prefix server logs
+      const serverPrefix = chalk.gray('server: ');
+      appProcess.stdout.pipe(prefixLines(serverPrefix)).pipe(process.stdout);
+      appProcess.stderr.pipe(prefixLines(serverPrefix)).pipe(process.stderr);
+      appProcess.catch(() => {});
 
-    await pollUrl(options.host, 10000);
+      // Poll the first page we are about to crawl (resolved against host) so we
+      // wait for the actual entry point to be serveable rather than the
+      // homepage, which may be a different (slower) page.
+      const healthcheckUrl = new URL(options.seedUrls[0] ?? '/', options.host).href;
+      await pollUrl(healthcheckUrl, SERVER_START_TIMEOUT);
 
-    console.log(`Server started on ${chalk.underline(options.host)}`);
+      console.log(`Server started on ${chalk.underline(options.host)}`);
+    }
+
+    return await runCrawl(options, startTime);
+  } finally {
+    // Always stop the server, even when startup or crawling throws. Without
+    // this, a failed healthcheck (or any error) would leave the dev server
+    // running, which on slow environments (e.g. Netlify) leads to orphaned
+    // servers piling up across retries.
+    if (controller) {
+      console.log(chalk.blue('Stopping server...'));
+      controller.abort();
+    }
   }
+}
 
+/**
+ * Runs the crawl against an already-running server.
+ * @param {ResolvedCrawlOptions} options - Fully resolved crawl options
+ * @param {number} startTime - Timestamp (ms) when the crawl began, for duration reporting
+ * @returns {Promise<CrawlResult>} Crawl results including all links, pages, and issues found
+ */
+async function runCrawl(options, startTime) {
   const knownTargets = await resolveKnownTargets(options);
 
   /** @type {Map<string, Promise<PageData>>} */
@@ -733,11 +760,6 @@ export async function crawl(rawOptions) {
 
   await queue.waitAll();
 
-  if (controller) {
-    console.log(chalk.blue('Stopping server...'));
-    controller.abort();
-  }
-
   const results = new Map(
     await Promise.all(
       Array.from(crawledPages.entries(), async ([a, b]) => /** @type {const} */ ([a, await b])),

package/src/eslint/mui/index.mjs

@@ -13,6 +13,7 @@ import straightQuotes from './rules/straight-quotes.mjs';
 import addUndefToOptional from './rules/add-undef-to-optional.mjs';
 import flattenParentheses from './rules/flatten-parentheses.mjs';
 import noPresentationRole from './rules/no-presentation-role.mjs';
+import noFloatingCleanup from './rules/no-floating-cleanup.mjs';
 
 /** @type {import('eslint').ESLint.Plugin} */
 const muiPlugin = {
@@ -37,6 +38,7 @@ const muiPlugin = {
     'add-undef-to-optional': /** @type {any} */ (addUndefToOptional),
     'flatten-parentheses': /** @type {any} */ (flattenParentheses),
     'no-presentation-role': noPresentationRole,
+    'no-floating-cleanup': /** @type {any} */ (noFloatingCleanup),
   },
 };
 

package/src/eslint/mui/rules/no-floating-cleanup.mjs

@@ -0,0 +1,187 @@
+import { ESLintUtils } from '@typescript-eslint/utils';
+import ts from 'typescript';
+
+/**
+ * no-floating-cleanup
+ *
+ * Like `@typescript-eslint/no-floating-promises`, but for functions: reports
+ * call expressions used as statements whose return value is a function
+ * (e.g. an `unsubscribe` / cleanup callback). Ignoring such a value usually
+ * means the subscription can never be torn down — a leak.
+ *
+ * Requires type information (parserOptions.project / projectService).
+ *
+ * Calls whose resolved signature declares a `this` return type are never
+ * reported: fluent / builder APIs (e.g. d3 scales) chain by returning `this`,
+ * so the discarded result is callable but not a leaked cleanup function.
+ *
+ * Opt-out at a call site, same convention as no-floating-promises:
+ *   void subscribe(cb);
+ */
+
+const RULE_NAME = 'no-floating-cleanup';
+
+const createRule = ESLintUtils.RuleCreator(
+  (name) =>
+    `https://github.com/mui/mui-public/blob/master/packages/code-infra/src/eslint/mui/rules/${name}.mjs`,
+);
+
+export default createRule({
+  meta: {
+    type: 'problem',
+    docs: {
+      description:
+        'Disallow ignoring returned cleanup/unsubscribe functions, which leaks subscriptions.',
+    },
+    messages: {
+      floatingCleanup:
+        "Return value of type '{{typeName}}' is ignored. This likely leaks a subscription — " +
+        'store the cleanup function, or discard it explicitly with the `void` operator.',
+    },
+    schema: [],
+  },
+  name: RULE_NAME,
+  defaultOptions: [],
+  create(context) {
+    const services = ESLintUtils.getParserServices(context);
+    const checker = services.program.getTypeChecker();
+
+    /**
+     * Does this type (or any union member) look like a cleanup function?
+     * @param {import('typescript').Type} type
+     * @returns {boolean}
+     */
+    function isCleanupType(type) {
+      if (type.isUnion()) {
+        return type.types.some(isCleanupType);
+      }
+      // Never fire on any/unknown/never — too noisy and not provable.
+      // eslint-disable-next-line no-bitwise -- TypeScript type flags are a bitmask
+      if (type.flags & (ts.TypeFlags.Any | ts.TypeFlags.Unknown | ts.TypeFlags.Never)) {
+        return false;
+      }
+
+      return checker.getSignaturesOfType(type, ts.SignatureKind.Call).length > 0;
+    }
+
+    /**
+     * @param {import('typescript').Type} type
+     * @returns {string}
+     */
+    function describeType(type) {
+      return (type.aliasSymbol && type.aliasSymbol.getName()) || checker.typeToString(type);
+    }
+
+    /**
+     * Does this call resolve to a signature that returns `this`? Fluent /
+     * builder APIs (e.g. d3 scales) chain by returning `this`, so the
+     * discarded result is callable but never a leaked cleanup function —
+     * those calls should not be reported. Covers both an explicit `: this`
+     * annotation and an inferred `this` return (no annotation).
+     * @param {import('@typescript-eslint/utils').TSESTree.Node} estreeCall
+     * @returns {boolean}
+     */
+    function returnsThis(estreeCall) {
+      /** @type {import('typescript').Node | undefined} */
+      let tsNode = services.esTreeNodeToTSNodeMap.get(estreeCall);
+      // Unwrap `await (...)` / parens down to the underlying call.
+      while (tsNode && (ts.isAwaitExpression(tsNode) || ts.isParenthesizedExpression(tsNode))) {
+        tsNode = tsNode.expression;
+      }
+      if (!tsNode || !(ts.isCallExpression(tsNode) || ts.isNewExpression(tsNode))) {
+        return false;
+      }
+      const declaration = checker.getResolvedSignature(tsNode)?.getDeclaration();
+      if (!declaration) {
+        return false;
+      }
+      // Explicit `: this` annotation.
+      if (declaration.type?.kind === ts.SyntaxKind.ThisType) {
+        return true;
+      }
+      // Inferred `this` return: the *declared* (uninstantiated) signature's
+      // return type is the polymorphic `this` type, which prints as `this`.
+      // (The resolved signature would have it bound to the receiver type.)
+      const declaredSignature = checker.getSignatureFromDeclaration(declaration);
+      return (
+        !!declaredSignature &&
+        checker.typeToString(checker.getReturnTypeOfSignature(declaredSignature)) === 'this'
+      );
+    }
+
+    /**
+     * Unwrap an expression-statement expression down to the calls whose
+     * results are being discarded. Mirrors the cases no-floating-promises
+     * handles: plain calls, optional chains, `await`, comma sequences,
+     * and the operand(s) of unary / logical / conditional expressions.
+     * A top-level `void` operator is the explicit opt-out, so we stop there.
+     * @param {import('@typescript-eslint/utils').TSESTree.Node} expr
+     * @param {import('@typescript-eslint/utils').TSESTree.Node[]} [out]
+     * @returns {import('@typescript-eslint/utils').TSESTree.Node[]}
+     */
+    function findDiscardedCalls(expr, out = []) {
+      switch (expr.type) {
+        case 'CallExpression':
+        case 'NewExpression':
+          out.push(expr);
+          break;
+        case 'ChainExpression':
+          findDiscardedCalls(expr.expression, out);
+          break;
+        case 'AwaitExpression':
+          // type of the AwaitExpression node is already the awaited type
+          if (expr.argument.type === 'CallExpression' || expr.argument.type === 'ChainExpression') {
+            out.push(expr);
+          }
+          break;
+        case 'UnaryExpression':
+          // `void expr` is the explicit opt-out; any other unary operator
+          // (e.g. `!subscribe()`) still discards the operand's result.
+          if (expr.operator !== 'void') {
+            findDiscardedCalls(expr.argument, out);
+          }
+          break;
+        case 'LogicalExpression':
+          // `a && subscribe()`, `a || subscribe()`, `a ?? subscribe()`:
+          // either side may be the discarded value.
+          findDiscardedCalls(expr.left, out);
+          findDiscardedCalls(expr.right, out);
+          break;
+        case 'ConditionalExpression':
+          // `cond ? subscribe() : other()`: the branches are discarded,
+          // not the test.
+          findDiscardedCalls(expr.consequent, out);
+          findDiscardedCalls(expr.alternate, out);
+          break;
+        case 'SequenceExpression':
+          // every value except the last is discarded; the last one is the
+          // statement's value, which is also discarded here
+          expr.expressions.forEach((subExpr) => findDiscardedCalls(subExpr, out));
+          break;
+        default:
+          break;
+      }
+      return out;
+    }
+
+    return {
+      /** @param {import('@typescript-eslint/utils').TSESTree.ExpressionStatement} node */
+      ExpressionStatement(node) {
+        findDiscardedCalls(node.expression).forEach((call) => {
+          // Fluent/builder calls return `this` for chaining — not a leak.
+          if (returnsThis(call)) {
+            return;
+          }
+          const type = services.getTypeAtLocation(call);
+          if (isCleanupType(type)) {
+            context.report({
+              node: call,
+              messageId: 'floatingCleanup',
+              data: { typeName: describeType(type) },
+            });
+          }
+        });
+      },
+    };
+  },
+});

package/src/eslint/mui/rules/no-floating-cleanup.test.mjs

@@ -0,0 +1,141 @@
+import { RuleTester } from '@typescript-eslint/rule-tester';
+import TSESlintParser from '@typescript-eslint/parser';
+import rule from './no-floating-cleanup.mjs';
+
+const ruleTester = new RuleTester({
+  languageOptions: {
+    parser: TSESlintParser,
+    parserOptions: {
+      tsconfigRootDir: import.meta.dirname,
+      projectService: {
+        allowDefaultProject: ['*.ts'],
+      },
+    },
+  },
+});
+
+ruleTester.run('no-floating-cleanup', rule, {
+  valid: [
+    {
+      name: 'stored cleanup function',
+      code: `
+type Unsubscribe = () => void;
+declare function subscribe(cb: () => void): Unsubscribe;
+function f() {
+  const un = subscribe(() => {});
+  un();
+}
+      `,
+    },
+    {
+      name: 'explicit void opt-out',
+      code: `
+type Unsubscribe = () => void;
+declare function subscribe(cb: () => void): Unsubscribe;
+function f() {
+  void subscribe(() => {});
+}
+      `,
+    },
+    {
+      name: 'call returning void',
+      code: `
+declare function noop(): void;
+function f() {
+  noop();
+}
+      `,
+    },
+    {
+      name: 'fluent builder methods returning `this`',
+      code: `
+interface Scale {
+  (value: number): number;
+  domain(d: number[]): this;
+  range(r: number[]): this;
+}
+declare const scale: Scale;
+function f() {
+  scale.domain([0, 1]);
+  scale.range([0, 100]);
+}
+      `,
+    },
+    {
+      name: 'fluent builder method with an inferred `this` return',
+      code: `
+class Builder {
+  configure() {
+    return this;
+  }
+}
+declare const builder: Builder;
+function f() {
+  builder.configure();
+}
+      `,
+    },
+  ],
+  invalid: [
+    {
+      name: 'discarded unsubscribe function',
+      code: `
+type Unsubscribe = () => void;
+declare function subscribe(cb: () => void): Unsubscribe;
+function f() {
+  subscribe(() => {});
+}
+      `,
+      errors: [{ messageId: 'floatingCleanup', line: 5 }],
+    },
+    {
+      name: 'call returning a fresh callable (not `this`)',
+      code: `
+interface Scale {
+  (value: number): number;
+  copy(): Scale;
+}
+declare const scale: Scale;
+function f() {
+  scale.copy();
+}
+      `,
+      errors: [{ messageId: 'floatingCleanup', line: 8 }],
+    },
+    {
+      name: 'discarded cleanup behind a unary operator',
+      code: `
+type Unsubscribe = () => void;
+declare function subscribe(cb: () => void): Unsubscribe;
+function f() {
+  !subscribe(() => {});
+}
+      `,
+      errors: [{ messageId: 'floatingCleanup', line: 5 }],
+    },
+    {
+      name: 'discarded cleanup in a logical expression',
+      code: `
+type Unsubscribe = () => void;
+declare function subscribe(cb: () => void): Unsubscribe;
+declare const enabled: boolean;
+function f() {
+  enabled && subscribe(() => {});
+}
+      `,
+      errors: [{ messageId: 'floatingCleanup', line: 6 }],
+    },
+    {
+      name: 'discarded cleanup in a conditional expression',
+      code: `
+type Unsubscribe = () => void;
+declare function subscribe(cb: () => void): Unsubscribe;
+declare const enabled: boolean;
+function f() {
+  enabled ? subscribe(() => {}) : undefined;
+}
+      `,
+      errors: [{ messageId: 'floatingCleanup', line: 6 }],
+    },
+  ],
+});