Sync Types

import { syncTypes } from '@mui/internal-docs-infra/pipeline/syncTypes';

// Sync the types (updates types.md and returns latest data)
const result = await syncTypes({
  typesMarkdownPath: '/absolute/path/to/types.md',
  rootContext: '/absolute/path/to/project',
  variants: { Default: '@base-ui/react/checkbox' },
  // Optional: watchSourceDirectly
  formattingOptions: {
    shortTypeUnionPrintWidth: 40,
    defaultValueUnionPrintWidth: 40,
  },
});

// Use the results
console.log(result.exports); // Record<string, { type: TypesMeta; additionalTypes: TypesMeta[] }>
console.log(result.additionalTypes); // TypesMeta[] for top-level types
console.log(result.allDependencies); // string[] - files to watch

const result = await syncTypes({
  typesMarkdownPath: '/absolute/path/to/types.md',
  rootContext: '/absolute/path/to/project',
  variants: { Default: '@base-ui/react/checkbox' },
  socketDir: '/tmp/my-custom-socket-dir', // For Windows compatibility
  performanceLogging: true,
});

interface SyncTypesOptions {
  /** Absolute path to the types.md file to generate */
  typesMarkdownPath: string;

  /** Root context directory (workspace root) */
  rootContext: string;

  /**
   * Map of variant name to file path (relative or package path).
   * For single component: { Default: './Component' }
   * For multiple: { CssModules: './css-modules/Component', Tailwind: './tailwind/Component' }
   */
  variants?: Record<string, string>;

  /**
   * When true, resolves library paths to their source files for watching.
   * Useful during development to watch the original source rather than built files.
   */
  watchSourceDirectly?: boolean;

  /** Options for formatting types in tables */
  formattingOptions?: FormatInlineTypeOptions;

  /**
   * Directory path for socket and lock files used for IPC between workers.
   * Useful for Windows where the default temp directory may not support Unix domain sockets.
   */
  socketDir?: string;

  /** Enable performance logging */
  performanceLogging?: boolean;

  /**
   * Options for updating the parent index page with component metadata.
   * When provided, calls syncPageIndex to update the parent directory's page.mdx
   * with props, dataAttributes, cssVariables, and parameters extracted from
   * component and hook types.
   */
  updateParentIndex?: {
    /** Base directory to stop recursion at when updating parent indexes */
    baseDir?: string;
    /** Name of the index file to update. @default 'page.mdx' */
    indexFileName?: string;
    /** Only update existing indexes, don't create new ones. @default false */
    onlyUpdateIndexes?: boolean;
    /** Directory to write marker files when indexes are updated */
    markerDir?: string;
    /** Throw an error if the index is out of date or missing */
    errorIfOutOfDate?: boolean;
  };
}

interface SyncTypesResult {
  /** Export data where each export has a main type and related additional types */
  exports: Record<string, { type: TypesMeta; additionalTypes: TypesMeta[] }>;

  /** Top-level non-namespaced types like InputType */
  additionalTypes: TypesMeta[];

  /** All dependencies that should be watched for changes */
  allDependencies: string[];

  /** Type name map from variant processing */
  typeNameMap?: Record<string, string>;

  /**
   * Maps variant names to the type names that originated from that variant.
   * Used for namespace imports (e.g., `* as Types`) to filter additionalTypes
   * to only show types from that specific module.
   */
  variantTypeNames: Record<string, string[]>;

  /** Whether the types.md file was updated (false if unchanged) */
  updated: boolean;

  /**
   * External types discovered during formatting.
   * Map from type name to its definition string.
   */
  externalTypes: Record<string, string>;
}

const typesMetaResult = await loadServerTypesMeta({
  typesMarkdownPath,
  rootContext,
  variants,
  watchSourceDirectly,
  formattingOptions,
  socketDir,
  externalTypesPattern,
});

const markdown = await generateTypesMarkdown(
  resourceName,
  allTypes,
  typeNameMap,
  externalTypes,
  variantData,
);

// Only write if changed
const existingMarkdown = await readFile(typesMarkdownPath, 'utf-8').catch(() => null);
if (existingMarkdown !== markdown) {
  await writeFile(typesMarkdownPath, markdown, 'utf-8');
}

await syncPageIndex({
  pagePath,
  metadata: pageMetadata, // props, dataAttributes, cssVariables, parameters
  baseDir: updateParentIndex.baseDir,
  indexFileName: updateParentIndex.indexFileName,
  // ...
});