@mui/internal-docs-infra 0.12.1-canary.41 → 0.12.1-canary.43

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mui/internal-docs-infra",
-  "version": "0.12.1-canary.41",
+  "version": "0.12.1-canary.43",
   "author": "MUI Team",
   "description": "MUI Infra - internal documentation creation tools.",
   "license": "MIT",
@@ -31,17 +31,17 @@
   "dependencies": {
     "@babel/runtime": "^7.29.7",
     "@csstools/postcss-light-dark-function": "^3.0.3",
-    "@csstools/postcss-relative-color-syntax": "^4.0.8",
+    "@csstools/postcss-relative-color-syntax": "^4.0.9",
     "@csstools/postcss-stepped-value-functions": "^5.0.4",
     "@orama/orama": "^3.1.18",
     "@orama/plugin-qps": "^3.1.18",
     "@orama/stemmers": "^3.1.18",
     "@orama/stopwords": "^3.1.18",
-    "@wooorm/starry-night": "^3.10.0",
+    "@wooorm/starry-night": "^3.11.0",
     "autoprefixer": "^10.5.4",
     "chalk": "^6.0.0",
     "clipboard-copy": "^4.0.1",
-    "es-toolkit": "^1.51.0",
+    "es-toolkit": "^1.52.0",
     "fflate": "^0.8.3",
     "hast-util-to-jsx-runtime": "^2.3.6",
     "hast-util-to-text": "^4.0.2",
@@ -62,7 +62,7 @@
     "remark-mdx": "^3.1.1",
     "remark-parse": "^11.0.0",
     "remark-stringify": "^11.0.0",
-    "remark-typography": "^0.8.1",
+    "remark-typography": "^0.8.2",
     "sucrase": "^3.35.1",
     "typescript": "npm:@typescript/typescript6@6.0.2",
     "typescript-api-extractor": "1.0.0-beta.6",
@@ -804,5 +804,5 @@
   "bin": {
     "docs-infra": "./cli/index.mjs"
   },
-  "gitSha": "96f05ba632fabe0c395fd6bf647b40c3bb717ee6"
+  "gitSha": "2a2c232ded2053934aa082b335952c525c6ea88c"
 }

package/pipeline/loadServerTypesMeta/builtInTypes.d.mts

@@ -0,0 +1,14 @@
+import type * as tae from 'typescript-api-extractor';
+/**
+ * Checks if a type name belongs to a built-in namespace.
+ *
+ * Names are compared whole: a `PickerConfig` of ours is not the built-in `Pick`.
+ */
+export declare function isBuiltInTypeName(typeName: tae.TypeName): boolean;
+/**
+ * Whether a type is one the reader already knows, rather than one these docs describe.
+ *
+ * A wrapper qualifies only when its arguments do too: the keys of `Omit<Config, 'size'>`
+ * come from `Config`, so naming the wrapper would describe nothing.
+ */
+export declare function isBuiltInTypeReference(type: tae.AnyType): boolean;

package/pipeline/loadServerTypesMeta/builtInTypes.mjs

@@ -0,0 +1,35 @@
+/**
+ * Type namespaces the reader is expected to know, which these docs are therefore not
+ * responsible for describing.
+ */
+const BUILT_IN_NAMESPACES = ['React', 'JSX', 'HTML', 'CSS', 'SVG', 'Omit', 'Pick', 'Partial'];
+
+/**
+ * Checks if a type name belongs to a built-in namespace.
+ *
+ * Names are compared whole: a `PickerConfig` of ours is not the built-in `Pick`.
+ */
+export function isBuiltInTypeName(typeName) {
+  return BUILT_IN_NAMESPACES.some(builtIn => typeName.name === builtIn || (typeName.namespaces?.includes(builtIn) ?? false));
+}
+
+/** The name a type is written as, for the node kinds that carry one. */
+function namedAs(type) {
+  return 'typeName' in type ? type.typeName : undefined;
+}
+
+/**
+ * Whether a type is one the reader already knows, rather than one these docs describe.
+ *
+ * A wrapper qualifies only when its arguments do too: the keys of `Omit<Config, 'size'>`
+ * come from `Config`, so naming the wrapper would describe nothing.
+ */
+export function isBuiltInTypeReference(type) {
+  const typeName = namedAs(type);
+  if (typeName === undefined || !isBuiltInTypeName(typeName)) {
+    return false;
+  }
+  return typeName.typeArguments?.every(
+  // Literals and intrinsics name nothing, so they cannot disqualify their wrapper.
+  argument => namedAs(argument.type) === undefined || isBuiltInTypeReference(argument.type)) ?? true;
+}

package/pipeline/loadServerTypesMeta/externalTypes.d.mts

@@ -25,11 +25,6 @@ export interface ExternalTypesCollector {
   /** Map of original export names to dotted display names, used to identify renamed own types */
   typeNameMap?: Record<string, string>;
 }
-/**
- * Checks if a type name belongs to a built-in namespace that should be skipped
- * during external type collection.
- */
-export declare function isBuiltInTypeName(typeName: tae.TypeName): boolean;
 /**
  * Checks whether a type name belongs to one of the module's own exports.
  * Matches both direct export names (e.g., `AlertDialogRootChangeEventReason`)

package/pipeline/loadServerTypesMeta/externalTypes.mjs

@@ -1,5 +1,6 @@
 import { uniq } from 'es-toolkit';
 import { isExternalType, isIntrinsicType, isUnionType, isObjectType, isLiteralType, isTypeOperatorType, isTypeQueryType } from "./typeGuards.mjs";
+import { isBuiltInTypeName } from "./builtInTypes.mjs";
 import { groupType, UNION_OR_INTERSECTION } from "./precedence.mjs";
 
 /**
@@ -14,20 +15,6 @@ import { groupType, UNION_OR_INTERSECTION } from "./precedence.mjs";
  * external types as they are encountered in the formatted output.
  */
 
-/**
- * Built-in type namespaces that should not be collected as external types.
- */
-const BUILT_IN_NAMESPACES = ['React', 'JSX', 'HTML', 'CSS', 'SVG', 'Omit', 'Pick', 'Partial'];
-
-/**
- * Checks if a type name belongs to a built-in namespace that should be skipped
- * during external type collection.
- */
-export function isBuiltInTypeName(typeName) {
-  const name = typeName.name || '';
-  return BUILT_IN_NAMESPACES.some(ns => name.startsWith(ns) || (typeName.namespaces?.includes(ns) ?? false));
-}
-
 /**
  * Checks whether a type name belongs to one of the module's own exports.
  * Matches both direct export names (e.g., `AlertDialogRootChangeEventReason`)

package/pipeline/loadServerTypesMeta/formatType.mjs

@@ -1,6 +1,7 @@
 import { uniq } from 'es-toolkit';
 import { isExternalType, isIntrinsicType, isUnionType, isIntersectionType, isObjectType, isAnonymousObjectType, isArrayType, isFunctionType, isLiteralType, isTupleType, isTypeParameterType, isTypeOperatorType, isTypeQueryType, isInternalTypeName } from "./typeGuards.mjs";
 import { isOwnTypeName, maybeCollectExternalUnion, maybeCollectExternalFunction, maybeCollectExternalReference } from "./externalTypes.mjs";
+import { isBuiltInTypeReference } from "./builtInTypes.mjs";
 import { prettyFormat } from "./format.mjs";
 import { groupType, UNION, UNION_OR_INTERSECTION } from "./precedence.mjs";
 /**
@@ -9,9 +10,17 @@ import { groupType, UNION, UNION_OR_INTERSECTION } from "./precedence.mjs";
  *
  * A type parameter operand is kept by name in raw declarations: the checker resolves
  * `keyof T` to its base constraint, which holds no type parameter to recover `T` from.
+ *
+ * A built-in operand is kept by name too. Its keys are the reader's to already know, and
+ * listing them buries the page: `keyof React.JSX.IntrinsicElements` says what a wall of
+ * tag names does not. Types the page is responsible for documenting still expand, since
+ * nothing else on the page would tell the reader what their keys are.
+ *
  * Both the union branch and the operator branch ask this, so they cannot disagree about
  * which operators expand. `formatExternalTypeDefinition` takes no options and always
- * expands, so it deliberately does not share this rule.
+ * expands, so it deliberately does not share this rule: an operator reached through a
+ * collected type still shows its keys in the External Types section, whichever reason
+ * kept it by name here.
  */
 function resolvedOperatorKeys(type, preserveTypeParameters) {
   if (!isTypeOperatorType(type) || type.resolvedType === undefined) {
@@ -20,6 +29,9 @@ function resolvedOperatorKeys(type, preserveTypeParameters) {
   if (preserveTypeParameters && isTypeParameterType(type.type)) {
     return undefined;
   }
+  if (isBuiltInTypeReference(type.type)) {
+    return undefined;
+  }
   return type.resolvedType;
 }
 export function formatType(type, options) {