@mui/internal-docs-infra 0.13.1-canary.0 → 0.13.1-canary.2

package/CodeHighlighter/buildStringFallback.mjs

@@ -1,5 +1,5 @@
 import { buildRootFallback } from "./fallbackFormat.mjs";
-import { parsePlainText } from "../pipeline/parseSource/index.mjs";
+import { parsePlainText } from "../pipeline/parseSource/createPlainTextRoot.mjs";
 function isPromiseLike(value) {
   return typeof value === 'object' && value !== null && typeof value.then === 'function';
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mui/internal-docs-infra",
-  "version": "0.13.1-canary.0",
+  "version": "0.13.1-canary.2",
   "author": "MUI Team",
   "description": "MUI Infra - internal documentation creation tools.",
   "license": "MIT",
@@ -814,5 +814,5 @@
   "bin": {
     "docs-infra": "./cli/index.mjs"
   },
-  "gitSha": "764e3b3cfc14293e74e93f3413609025f502bab9"
+  "gitSha": "409e39410c3eac0b4743be41962f632aab3fc4a3"
 }

package/pipeline/loadServerTypesMeta/constantGroups.d.mts

@@ -0,0 +1,48 @@
+import ts from 'typescript';
+import type * as tae from 'typescript-api-extractor';
+/** Which of a component's tables a constant group holds. */
+export type ConstantGroupKind = 'dataAttributes' | 'cssVariables';
+export interface ConstantGroupTarget {
+  /** The component's name as the entrypoint exports it, e.g. `Toolbar.Button` */
+  component: string;
+  kind: ConstantGroupKind;
+}
+/** The constant groups holding one component's tables. */
+export type ComponentConstantGroups = Partial<Record<ConstantGroupKind, tae.EnumNode>>;
+/** The value of a constant in a constant group. */
+type ConstantValue = string | number;
+/**
+ * Finds the entrypoint's namespace exports whose module holds nothing but literal constants,
+ * e.g. `export * as ButtonDataAttributes from './ButtonDataAttributes'`, with their values.
+ * Namespaces nested in other namespace exports are found too, under their dotted path
+ * (`Toolbar.ButtonDataAttributes`).
+ *
+ * The parser flattens such a namespace into one export per member and cannot tell a constant
+ * from a type alias of the same literal, so the checker is asked instead.
+ *
+ * @returns Member values keyed by namespace path, then member name
+ */
+export declare function findConstantNamespaces(entrypoint: string, program: ts.Program): Map<string, Map<string, ConstantValue>>;
+/**
+ * Collapses the flattened members of each constant namespace (`ButtonDataAttributes.open`)
+ * into a single enum-shaped export named after the namespace, in place of its first member.
+ */
+export declare function foldConstantNamespaces(exports: tae.ExportNode[], namespaces: Map<string, Map<string, ConstantValue>>): tae.ExportNode[];
+/**
+ * Writes the declaration of a constant group as it is exported: a namespace of constants
+ * for a namespace export, an enum otherwise.
+ */
+export declare function formatConstantGroupDeclaration(name: string, group: tae.EnumNode, asNamespace: boolean): string;
+/**
+ * Resolves which component each constant group documents from its name: the component's
+ * name with its dots removed, followed by `DataAttributes` or `CssVariables`.
+ *
+ * Throws when the name before the suffix is not exactly one of the exported components.
+ *
+ * @returns Targets keyed by the group's export name, and each component's groups
+ */
+export declare function matchConstantGroups(exports: tae.ExportNode[]): {
+  targets: Map<string, ConstantGroupTarget>;
+  byComponent: Map<string, ComponentConstantGroups>;
+};
+export {};

package/pipeline/loadServerTypesMeta/constantGroups.mjs

@@ -0,0 +1,202 @@
+import ts from 'typescript';
+import { EnumMember, EnumNode, ExportNode, TypeName } from 'typescript-api-extractor';
+import { formatPropertyComment } from "./formatType.mjs";
+import { isComponentType, isEnumType } from "./typeGuards.mjs";
+
+/** Which of a component's tables a constant group holds. */
+
+/**
+ * A constant group is a named set of constant values an entrypoint publishes, either as an
+ * enum or as a namespace of constants (`export * as ButtonDataAttributes from './…'`); both
+ * are represented as an enum-shaped export. Its name tells which component table it holds:
+ * the component's name with its dots removed, followed by one of these suffixes, e.g.
+ * `ToolbarButtonDataAttributes` holds the data attributes of `Toolbar.Button`.
+ */
+const KIND_SUFFIXES = {
+  dataAttributes: 'DataAttributes',
+  cssVariables: 'CssVariables'
+};
+
+/** The constant groups holding one component's tables. */
+
+function resolveAlias(symbol, checker) {
+  // eslint-disable-next-line no-bitwise -- TypeScript symbol flags are a bitmask
+  return symbol.flags & ts.SymbolFlags.Alias ? checker.getAliasedSymbol(symbol) : symbol;
+}
+
+/** The value of a constant in a constant group. */
+
+/**
+ * Reads the value of a `const` holding a string or number literal.
+ */
+function readLiteralConstant(symbol, checker) {
+  const declaration = symbol.valueDeclaration;
+  if (!declaration || !ts.isVariableDeclaration(declaration) ||
+  // eslint-disable-next-line no-bitwise -- TypeScript node flags are a bitmask
+  !(ts.getCombinedNodeFlags(declaration) & ts.NodeFlags.Const)) {
+    return undefined;
+  }
+  const type = checker.getTypeOfSymbol(symbol);
+  return type.isStringLiteral() || type.isNumberLiteral() ? type.value : undefined;
+}
+
+/**
+ * Reads a module's exports as constant values, when it exports nothing but literal constants.
+ */
+function readConstantModule(moduleSymbol, checker) {
+  const values = new Map();
+  const members = checker.getExportsOfModule(moduleSymbol);
+  const isConstantModule = members.length > 0 && members.every(member => {
+    const value = readLiteralConstant(resolveAlias(member, checker), checker);
+    if (value === undefined) {
+      return false;
+    }
+    values.set(member.name, value);
+    return true;
+  });
+  return isConstantModule ? values : undefined;
+}
+
+/**
+ * Finds the entrypoint's namespace exports whose module holds nothing but literal constants,
+ * e.g. `export * as ButtonDataAttributes from './ButtonDataAttributes'`, with their values.
+ * Namespaces nested in other namespace exports are found too, under their dotted path
+ * (`Toolbar.ButtonDataAttributes`).
+ *
+ * The parser flattens such a namespace into one export per member and cannot tell a constant
+ * from a type alias of the same literal, so the checker is asked instead.
+ *
+ * @returns Member values keyed by namespace path, then member name
+ */
+export function findConstantNamespaces(entrypoint, program) {
+  const namespaces = new Map();
+  const sourceFile = program.getSourceFile(entrypoint);
+  const checker = program.getTypeChecker();
+  const entrypointSymbol = sourceFile && checker.getSymbolAtLocation(sourceFile);
+  const visited = new Set();
+  const visit = (moduleSymbol, prefix) => {
+    for (const exportSymbol of checker.getExportsOfModule(moduleSymbol)) {
+      if (exportSymbol.declarations?.some(ts.isNamespaceExport)) {
+        const target = checker.getAliasedSymbol(exportSymbol);
+        const path = `${prefix}${exportSymbol.name}`;
+        const values = readConstantModule(target, checker);
+        if (values) {
+          namespaces.set(path, values);
+        } else if (!visited.has(target)) {
+          visited.add(target);
+          visit(target, `${path}.`);
+        }
+      }
+    }
+  };
+  if (entrypointSymbol) {
+    visit(entrypointSymbol, '');
+  }
+  return namespaces;
+}
+
+/**
+ * Collapses the flattened members of each constant namespace (`ButtonDataAttributes.open`)
+ * into a single enum-shaped export named after the namespace, in place of its first member.
+ */
+export function foldConstantNamespaces(exports, namespaces) {
+  if (namespaces.size === 0) {
+    return exports;
+  }
+  const groups = new Map();
+  const folded = [];
+  for (const node of exports) {
+    // Members sit directly under their namespace, which may itself be nested
+    // (`Toolbar.ButtonDataAttributes.pressed`).
+    const dot = node.name.lastIndexOf('.');
+    const namespace = dot === -1 ? undefined : node.name.slice(0, dot);
+    const memberName = node.name.slice(dot + 1);
+    const value = namespace === undefined ? undefined : namespaces.get(namespace)?.get(memberName);
+    if (namespace === undefined || value === undefined) {
+      folded.push(node);
+    } else {
+      let members = groups.get(namespace);
+      if (!members) {
+        members = [];
+        groups.set(namespace, members);
+        folded.push(new ExportNode(namespace, new EnumNode(new TypeName(namespace), members, undefined), undefined));
+      }
+      // Typed as a string, but the parser stores numeric enum values as numbers too; do
+      // the same so both forms render alike.
+      members.push(new EnumMember(memberName, value, node.documentation));
+    }
+  }
+  return folded;
+}
+
+/**
+ * Writes the declaration of a constant group as it is exported: a namespace of constants
+ * for a namespace export, an enum otherwise.
+ */
+export function formatConstantGroupDeclaration(name, group, asNamespace) {
+  const members = group.members.map(member => {
+    // Enum members hold the literal's value, numbers included; a computed member has none.
+    const value = member.value;
+    const literal = typeof value === 'number' ? String(value) : JSON.stringify(value);
+    const comment = member.documentation ? formatPropertyComment(member.documentation) : undefined;
+    let declaration = `${member.name} = ${literal},`;
+    if (asNamespace) {
+      declaration = `const ${member.name}: ${literal};`;
+    } else if (value === undefined) {
+      declaration = `${member.name},`;
+    }
+    return comment ? `${comment}\n${declaration}` : declaration;
+  });
+  return asNamespace ? `declare namespace ${name} {\n${members.join('\n')}\n}` : `enum ${name} {\n${members.join('\n')}\n}`;
+}
+
+/**
+ * Resolves which component each constant group documents from its name: the component's
+ * name with its dots removed, followed by `DataAttributes` or `CssVariables`.
+ *
+ * Throws when the name before the suffix is not exactly one of the exported components.
+ *
+ * @returns Targets keyed by the group's export name, and each component's groups
+ */
+export function matchConstantGroups(exports) {
+  const targets = new Map();
+  const byComponent = new Map();
+  const componentsByFlatName = new Map();
+  for (const node of exports) {
+    if (isComponentType(node.type)) {
+      const flatName = node.name.replaceAll('.', '');
+      const names = componentsByFlatName.get(flatName);
+      if (names) {
+        names.push(node.name);
+      } else {
+        componentsByFlatName.set(flatName, [node.name]);
+      }
+    }
+  }
+  const kinds = Object.keys(KIND_SUFFIXES);
+  for (const node of exports) {
+    // Names are compared without dots, like the component names they stand for, so a group
+    // exported inside a namespace (`Toolbar.ButtonDataAttributes`) matches too.
+    const groupName = node.name.replaceAll('.', '');
+    const kind = kinds.find(candidate => groupName.endsWith(KIND_SUFFIXES[candidate]) && groupName.length > KIND_SUFFIXES[candidate].length);
+    if (kind && isEnumType(node.type)) {
+      const flatName = groupName.slice(0, -KIND_SUFFIXES[kind].length);
+      const components = componentsByFlatName.get(flatName) ?? [];
+      if (components.length !== 1) {
+        throw new Error(components.length === 0 ? `[constantGroups] ${node.name} - no exported component is named ${flatName}` : `[constantGroups] ${node.name} - ${components.join(', ')} are all named ${flatName}`);
+      }
+      const [component] = components;
+      targets.set(node.name, {
+        component,
+        kind
+      });
+      const groups = byComponent.get(component) ?? {};
+      groups[kind] ??= node.type;
+      byComponent.set(component, groups);
+    }
+  }
+  return {
+    targets,
+    byComponent
+  };
+}

package/pipeline/loadServerTypesMeta/formatComponent.d.mts

@@ -1,5 +1,6 @@
 import type * as tae from 'typescript-api-extractor';
 import type { FormattedProperty, FormattedEnumMember, FormatInlineTypeOptions, DescriptionReplacement } from "./format.mjs";
+import type { ComponentConstantGroups } from "./constantGroups.mjs";
 import type { TypeRewriteContext } from "./rewriteTypes.mjs";
 import type { ExternalTypesCollector } from "./externalTypes.mjs";
 import type { HastRoot } from "../../CodeHighlighter/types.mjs";
@@ -20,10 +21,8 @@ export type ComponentTypeMeta = {
  * Options for customizing component data formatting.
  */
 export interface FormatComponentOptions {
-  /** Suffix for data attributes enum name (default: 'DataAttributes') */
-  dataAttributesSuffix?: string;
-  /** Suffix for CSS variables enum name (default: 'CssVars') */
-  cssVariablesSuffix?: string;
+  /** The constant groups holding this component's tables (see `matchConstantGroups`) */
+  constantGroups?: ComponentConstantGroups;
   /** Pattern/replacement pairs to apply to descriptions */
   descriptionReplacements?: DescriptionReplacement[];
   /** Options for inline type formatting (e.g., unionPrintWidth) */
@@ -44,7 +43,7 @@ export interface FormatComponentOptions {
  */
 export declare function formatComponentData(component: tae.ExportNode & {
   type: tae.ComponentNode;
-}, allExports: tae.ExportNode[], typeNameMap: Record<string, string>, rewriteContext: TypeRewriteContext, options?: FormatComponentOptions): Promise<ComponentTypeMeta>;
+}, typeNameMap: Record<string, string>, rewriteContext: TypeRewriteContext, options?: FormatComponentOptions): Promise<ComponentTypeMeta>;
 /**
  * Type guard to check if an export is a public component that should be documented.
  *

package/pipeline/loadServerTypesMeta/formatComponent.mjs

@@ -20,10 +20,8 @@ import * as memberOrder from "../loadServerTypesText/order.mjs";
  *
  * The component must be validated with `isPublicComponent()` before calling this function.
  */
-export async function formatComponentData(component, allExports, typeNameMap, rewriteContext, options = {}) {
+export async function formatComponentData(component, typeNameMap, rewriteContext, options = {}) {
   const {
-    dataAttributesSuffix = 'DataAttributes',
-    cssVariablesSuffix = 'CssVars',
     descriptionReplacements,
     formatting,
     externalTypes
@@ -34,91 +32,11 @@ export async function formatComponentData(component, allExports, typeNameMap, re
   const descriptionText = component.documentation?.description ? applyDescriptionReplacements(component.documentation.description, descriptionReplacements) : undefined;
   const description = descriptionText ? await parseMarkdownToHast(descriptionText) : undefined;
 
-  // Find data attributes and CSS variables in a single loop
-  let dataAttributes;
-  let cssVariables;
-
-  // For DataAttributes/CssVars lookup, use the originalName (before transformations).
-  // Example for re-exported component:
-  //   - Component: ContextMenu.Backdrop (transformed from MenuBackdrop)
-  //   - originalName: MenuBackdrop
-  //   - We look for: MenuBackdropDataAttributes (using originalName + suffix)
-  //   - That export's originalName will also be MenuBackdropDataAttributes
-  const originalName = component.originalName;
-  const componentNameForLookup = originalName || component.name.replace(/\./g, '');
-  const dataAttributesName = `${componentNameForLookup}${dataAttributesSuffix}`;
-  const cssVariablesName = `${componentNameForLookup}${cssVariablesSuffix}`;
-
-  // Get the component's short name (e.g., "Trigger" from "AlertDialog.Trigger")
-  const componentShortName = component.name.split('.').pop() || component.name;
-  const dataAttributesSuffixWithShortName = `${componentShortName}${dataAttributesSuffix}`;
-  const cssVariablesSuffixWithShortName = `${componentShortName}${cssVariablesSuffix}`;
-
-  // Look for DataAttributes/CssVars by checking originalName on each export
-  // First pass: exact match
-  for (const node of allExports) {
-    const nodeOriginalName = node.originalName;
-    const nodeName = nodeOriginalName || node.name;
-    if (nodeName === dataAttributesName) {
-      dataAttributes = node;
-    } else if (nodeName === cssVariablesName) {
-      cssVariables = node;
-    }
-
-    // Early exit if we found both
-    if (dataAttributes && cssVariables) {
-      break;
-    }
-  }
-
-  // Fallback: For re-exported components (like AlertDialog.Trigger which re-exports DialogTrigger),
-  // the DataAttributes file uses the original component name (DialogTriggerDataAttributes).
-  // If we didn't find an exact match, look for any DataAttributes ending with the component's
-  // short name (e.g., "TriggerDataAttributes").
-  // Priority: prefer DataAttributes whose prefix is contained in the component's namespace
-  // (e.g., for AlertDialog.Trigger, prefer DialogTriggerDataAttributes over MenuTriggerDataAttributes)
-  if (!dataAttributes || !cssVariables) {
-    // Get the component's namespace (e.g., "AlertDialog" from "AlertDialog.Trigger")
-    const componentNamespace = component.name.includes('.') ? component.name.substring(0, component.name.lastIndexOf('.')) : '';
-
-    // Collect all matching candidates
-    const dataAttributesCandidates = [];
-    const cssVariablesCandidates = [];
-    for (const node of allExports) {
-      const nodeOriginalName = node.originalName;
-      const nodeName = nodeOriginalName || node.name;
-
-      // Check if this export ends with the component's short name + suffix
-      if (!dataAttributes && nodeName.endsWith(dataAttributesSuffixWithShortName)) {
-        // Extract the prefix (e.g., "Dialog" from "DialogTriggerDataAttributes")
-        const prefix = nodeName.slice(0, -dataAttributesSuffixWithShortName.length);
-        // Priority: 2 if prefix is contained in namespace (related component), 1 otherwise
-        const priority = componentNamespace.includes(prefix) ? 2 : 1;
-        dataAttributesCandidates.push({
-          node,
-          priority
-        });
-      }
-      if (!cssVariables && nodeName.endsWith(cssVariablesSuffixWithShortName)) {
-        const prefix = nodeName.slice(0, -cssVariablesSuffixWithShortName.length);
-        const priority = componentNamespace.includes(prefix) ? 2 : 1;
-        cssVariablesCandidates.push({
-          node,
-          priority
-        });
-      }
-    }
-
-    // Select the highest priority candidate
-    if (!dataAttributes && dataAttributesCandidates.length > 0) {
-      dataAttributesCandidates.sort((a, b) => b.priority - a.priority);
-      dataAttributes = dataAttributesCandidates[0].node;
-    }
-    if (!cssVariables && cssVariablesCandidates.length > 0) {
-      cssVariablesCandidates.sort((a, b) => b.priority - a.priority);
-      cssVariables = cssVariablesCandidates[0].node;
-    }
-  }
+  // The component's data attributes and CSS variables are the constant groups matched to it.
+  const {
+    dataAttributes,
+    cssVariables
+  } = options.constantGroups ?? {};
   const raw = {
     name: component.name,
     description,
@@ -131,8 +49,8 @@ export async function formatComponentData(component, allExports, typeNameMap, re
       externalTypes,
       descriptionReplacements
     }), options.ordering?.props ?? memberOrder.props),
-    dataAttributes: dataAttributes && dataAttributes.type.kind === 'enum' ? sortObjectByKeys(await formatEnum(dataAttributes.type, descriptionReplacements), options.ordering?.dataAttributes ?? memberOrder.dataAttributes) : {},
-    cssVariables: cssVariables && cssVariables.type.kind === 'enum' ? sortObjectByKeys(await formatEnum(cssVariables.type, descriptionReplacements), options.ordering?.cssVariables ?? memberOrder.cssVariables) : {}
+    dataAttributes: dataAttributes ? sortObjectByKeys(await formatEnum(dataAttributes, descriptionReplacements), options.ordering?.dataAttributes ?? memberOrder.dataAttributes) : {},
+    cssVariables: cssVariables ? sortObjectByKeys(await formatEnum(cssVariables, descriptionReplacements), options.ordering?.cssVariables ?? memberOrder.cssVariables) : {}
   };
 
   // Post-process type strings to align naming across re-exports and hide internal suffixes.

package/pipeline/loadServerTypesMeta/formatRaw.d.mts

@@ -1,5 +1,6 @@
 import type * as tae from 'typescript-api-extractor';
 import type { FormattedProperty, FormatInlineTypeOptions, DescriptionReplacement } from "./format.mjs";
+import type { ConstantGroupTarget } from "./constantGroups.mjs";
 import type { TypeRewriteContext } from "./rewriteTypes.mjs";
 import type { ExternalTypesCollector } from "./externalTypes.mjs";
 import type { HastRoot } from "../../CodeHighlighter/types.mjs";
@@ -12,7 +13,7 @@ export interface ReExportInfo {
   /** Anchor slug for linking (e.g., "#trigger") */
   slug: string;
   /** What kind of type this re-exports */
-  suffix: 'props' | 'css-variables' | 'data-attributes';
+  suffix: 'props';
 }
 /**
  * Formatted raw type metadata with the type declaration as a formatted code string.
@@ -46,11 +47,11 @@ export type RawTypeMeta = {
    */
   reExportOf?: ReExportInfo;
   /**
-   * For DataAttributes types, the component name this type belongs to.
+   * For constant groups holding a component's data attributes, that component's name.
    */
   dataAttributesOf?: string;
   /**
-   * For CssVars types, the component name this type belongs to.
+   * For constant groups holding a component's CSS variables, that component's name.
    */
   cssVarsOf?: string;
   /**
@@ -75,6 +76,10 @@ export interface FormatRawOptions {
   externalTypes?: ExternalTypesCollector;
   /** Pattern/replacement pairs to apply to descriptions */
   descriptionReplacements?: DescriptionReplacement[];
+  /** The component table this constant group holds (see `matchConstantGroups`) */
+  constantGroup?: ConstantGroupTarget;
+  /** Whether the constant group was exported as a namespace of constants rather than an enum */
+  constantNamespace?: boolean;
 }
 /**
  * Formats a raw type export into a structured metadata object with formatted code.

package/pipeline/loadServerTypesMeta/formatRaw.mjs

@@ -1,6 +1,7 @@
 import { prettyFormat, parseMarkdownToHast, applyDescriptionReplacements, formatProperties, extractTypeParameters } from "./format.mjs";
 import { formatType } from "./formatType.mjs";
 import { isEnumType, isObjectType } from "./typeGuards.mjs";
+import { formatConstantGroupDeclaration } from "./constantGroups.mjs";
 import { rewriteTypeStringsDeep } from "./rewriteTypes.mjs";
 
 /**
@@ -33,7 +34,9 @@ import { rewriteTypeStringsDeep } from "./rewriteTypes.mjs";
  */
 export async function formatRawData(exportNode, displayName, typeNameMap, rewriteContext, _options = {}) {
   const {
-    descriptionReplacements
+    descriptionReplacements,
+    constantGroup,
+    constantNamespace
   } = _options;
   const descriptionText = exportNode.documentation?.description ? applyDescriptionReplacements(exportNode.documentation.description, descriptionReplacements) : undefined;
   const description = descriptionText ? await parseMarkdownToHast(descriptionText) : undefined;
@@ -50,8 +53,9 @@ export async function formatRawData(exportNode, displayName, typeNameMap, rewrit
       };
     }));
 
-    // For enums, still generate the code block but also include members
-    const formattedCode = await generateFormattedCode(exportNode, displayName, typeNameMap);
+    // For enums, still generate the code block but also include members. The declaration
+    // follows how the group is exported: an enum, or a namespace of constants.
+    const formattedCode = await prettyFormat(formatConstantGroupDeclaration(displayName.replace(/\./g, ''), exportNode.type, Boolean(constantNamespace)), null);
 
     // Rewrite type names in descriptions (but NOT in formattedCode which is valid TypeScript syntax)
     const rewrittenDescriptionText = descriptionText ? rewriteTypeStringsDeep(descriptionText, rewriteContext) : undefined;
@@ -62,36 +66,11 @@ export async function formatRawData(exportNode, displayName, typeNameMap, rewrit
       formattedCode,
       enumMembers
     };
-    return raw;
-  }
-
-  // Handle DataAttributes types
-  if (displayName.endsWith('.DataAttributes')) {
-    const componentName = displayName.replace('.DataAttributes', '');
-    const formattedCode = await generateFormattedCode(exportNode, displayName, typeNameMap);
-    const rewrittenDescriptionText = descriptionText ? rewriteTypeStringsDeep(descriptionText, rewriteContext) : undefined;
-    const raw = {
-      name: displayName,
-      description,
-      descriptionText: rewrittenDescriptionText,
-      formattedCode,
-      dataAttributesOf: componentName
-    };
-    return raw;
-  }
-
-  // Handle CssVars types
-  if (displayName.endsWith('.CssVars')) {
-    const componentName = displayName.replace('.CssVars', '');
-    const formattedCode = await generateFormattedCode(exportNode, displayName, typeNameMap);
-    const rewrittenDescriptionText = descriptionText ? rewriteTypeStringsDeep(descriptionText, rewriteContext) : undefined;
-    const raw = {
-      name: displayName,
-      description,
-      descriptionText: rewrittenDescriptionText,
-      formattedCode,
-      cssVarsOf: componentName
-    };
+    if (constantGroup?.kind === 'dataAttributes') {
+      raw.dataAttributesOf = constantGroup.component;
+    } else if (constantGroup?.kind === 'cssVariables') {
+      raw.cssVarsOf = constantGroup.component;
+    }
     return raw;
   }
 

package/pipeline/loadServerTypesMeta/formatType.d.mts

@@ -20,4 +20,9 @@ export declare function formatType(type: tae.AnyType, options: FormatTypeOptions
  * processing, then runs the output through `prettyFormat()` for consistent styling.
  */
 export declare function prettyFormatType(type: tae.AnyType, options: FormatTypeOptions): Promise<string>;
-export declare function getFullyQualifiedName(typeName: tae.TypeName, exportNames: string[], typeNameMap: Record<string, string>, preserveTypeParameters?: boolean): string;
+export declare function getFullyQualifiedName(typeName: tae.TypeName, exportNames: string[], typeNameMap: Record<string, string>, preserveTypeParameters?: boolean): string;
+/**
+ * Formats a JSDoc comment block from property documentation.
+ * Returns undefined if no meaningful content to document.
+ */
+export declare function formatPropertyComment(documentation: tae.Documentation): string | undefined;

package/pipeline/loadServerTypesMeta/formatType.mjs

@@ -818,7 +818,7 @@ function normalizeQuotes(str) {
  * Formats a JSDoc comment block from property documentation.
  * Returns undefined if no meaningful content to document.
  */
-function formatPropertyComment(documentation) {
+export function formatPropertyComment(documentation) {
   const lines = [];
   if (documentation.description) {
     lines.push(...documentation.description.split('\n'));

package/pipeline/loadServerTypesMeta/loadServerTypesMeta.d.mts

@@ -119,7 +119,6 @@ export interface LoadServerTypesMetaResult extends OrganizeTypesResult<TypesMeta
  * This function handles:
  * - Loading TypeScript configuration
  * - Resolving library source files and variants
- * - Finding meta files (DataAttributes, CssVars)
  * - Processing types via worker thread
  * - Formatting component, hook, function, and raw types
  * - Collecting external types referenced in props/params