@mui/internal-code-infra 0.0.4-canary.1 → 0.0.4-canary.100

package/build/cli/cmdRenameScope.d.mts

@@ -0,0 +1,18 @@
+#!/usr/bin/env node
+export type Args = {
+    /**
+     * Source and target scope
+     */
+    alias: [string, string];
+};
+/**
+ * @typedef {Object} Args
+ * @property {[string, string]} alias Source and target scope
+ */
+/**
+ * @param {string} alias
+ * @returns {[string, string]}
+ */
+export declare function parseAlias(alias: string): [string, string];
+declare const _default: import('yargs').CommandModule<{}, Args>;
+export default _default;

package/build/cli/cmdSetVersionOverrides.d.mts

@@ -1,6 +1,9 @@
 #!/usr/bin/env node
 export type Args = {
+    /**
+     * - Package version specifiers in format 'package@version'
+     */
     pkg?: string[];
 };
-declare const _default: import("yargs").CommandModule<{}, Args>;
-export default /** @type {import('yargs').CommandModule<{}, Args>} */ _default;
+declare const _default: import('yargs').CommandModule<{}, Args>;
+export default _default;

package/build/cli/cmdVale.d.mts

@@ -0,0 +1,46 @@
+export type ValeOS = 'Linux' | 'macOS' | 'Windows';
+export type ValeArch = '64-bit' | 'arm64';
+/**
+ * Extracts the replacement text from a vale alert.
+ * Returns null if no replacement can be determined.
+ * @param {{ Action: { Name: string; Params: string[] | null }; Message: string }} alert
+ * @returns {string | null}
+ */
+export declare function getReplacementText(alert: {
+    Action: {
+        Name: string;
+        Params: string[] | null;
+    };
+    Message: string;
+}): string | null;
+/**
+ * Applies auto-fixes from vale alerts to the source files.
+ * Processes alerts in reverse order within each line to preserve column positions.
+ * @param {Record<string, Array<{ Action: { Name: string; Params: string[] | null }; Span: [number, number]; Check: string; Message: string; Severity: string; Match: string; Line: number }>>} results
+ * @param {'all' | 'error'} fixLevel
+ * @returns {Promise<{ fixed: number; skipped: number }>}
+ */
+export declare function applyFixes(results: Record<string, Array<{
+    Action: {
+        Name: string;
+        Params: string[] | null;
+    };
+    Span: [number, number];
+    Check: string;
+    Message: string;
+    Severity: string;
+    Match: string;
+    Line: number;
+}>>, fixLevel: 'all' | 'error'): Promise<{
+    fixed: number;
+    skipped: number;
+}>;
+export type Args = {
+    'vale-version': string;
+    'auto-fix': 'all' | 'error' | undefined;
+};
+/**
+ * @typedef {{ 'vale-version': string; 'auto-fix': 'all' | 'error' | undefined;  }} Args
+ */
+declare const _default: import('yargs').CommandModule<{}, Args>;
+export default _default;

package/build/cli/cmdValidateBuiltTypes.d.mts

@@ -1,2 +1,2 @@
-declare const _default: import("yargs").CommandModule<{}, {}>;
-export default /** @type {import('yargs').CommandModule<{}, {}>} */ _default;
+declare const _default: import('yargs').CommandModule<{}, {}>;
+export default _default;

package/build/eslint/baseConfig.d.mts

@@ -4,11 +4,13 @@
  * @param {boolean} [params.consistentTypeImports] - Whether to enforce consistent type imports.
  * @param {boolean} [params.materialUi] - Whether to enable Material UI specific rules (mui/material-ui-*).
  * @param {string} [params.baseDirectory] - The base directory for the configuration.
+ * @param {boolean} [params.markdown] - @deprecated Markdown/MDX linting is enabled by default; this option no longer needs to be passed. To skip markdown linting, use eslint ignore patterns for the relevant files.
  * @returns {import('eslint').Linter.Config[]}
  */
-export declare function createBaseConfig({ enableReactCompiler, consistentTypeImports, materialUi, baseDirectory }?: {
+export declare function createBaseConfig({ enableReactCompiler, consistentTypeImports, materialUi, markdown, baseDirectory, }?: {
     enableReactCompiler?: boolean;
     consistentTypeImports?: boolean;
     materialUi?: boolean;
     baseDirectory?: string;
+    markdown?: boolean;
 }): import('eslint').Linter.Config[];

package/build/eslint/mui/rules/disallow-react-api-in-server-components.d.mts

@@ -1,2 +1,2 @@
-declare const _default: import("eslint").Rule.RuleModule;
-export default /** @type {import('eslint').Rule.RuleModule} */ _default;
+declare const _default: import('eslint').Rule.RuleModule;
+export default _default;

package/build/eslint/mui/rules/docgen-ignore-before-comment.d.mts

@@ -1,2 +1,2 @@
-declare const _default: import("eslint").Rule.RuleModule;
-export default /** @type {import('eslint').Rule.RuleModule} */ _default;
+declare const _default: import('eslint').Rule.RuleModule;
+export default _default;

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/build/eslint/mui/rules/no-guarded-throw.d.mts

@@ -0,0 +1,31 @@
+/**
+ * ESLint rule that disallows throw statements guarded by process.env.NODE_ENV checks.
+ *
+ * NODE_ENV guards cause throw statements to only execute in certain environments,
+ * leading to inconsistent control flow between development and production. Whether
+ * the guard excludes production (tree-shaking the throw away) or targets production
+ * specifically, the result is environment-dependent behavior that should be avoided.
+ *
+ * The rule stops at function boundaries, so throws inside functions defined within
+ * a NODE_ENV guard are not flagged, as the function may be called from other contexts.
+ *
+ * @example
+ * // Invalid - throw only in development, removed in production
+ * if (process.env.NODE_ENV !== 'production') {
+ *   throw new Error('Missing required prop');
+ * }
+ *
+ * @example
+ * // Invalid - throw only in production
+ * if (process.env.NODE_ENV === 'production') {
+ *   throw new Error('Production-only error');
+ * }
+ *
+ * @example
+ * // Valid - unconditional throw
+ * throw new Error('Something went wrong');
+ *
+ * @type {import('eslint').Rule.RuleModule}
+ */
+declare const rule: import('eslint').Rule.RuleModule;
+export default rule;

package/build/eslint/mui/rules/no-presentation-role.d.mts

@@ -0,0 +1,5 @@
+/**
+ * @type {import('eslint').Rule.RuleModule}
+ */
+declare const rule: import('eslint').Rule.RuleModule;
+export default rule;

package/build/eslint/mui/rules/no-restricted-resolved-imports.d.mts

@@ -1,5 +1,11 @@
 export type PatternConfig = {
+    /**
+     * - The pattern to match against resolved imports
+     */
     pattern: string;
+    /**
+     * - Custom message to show when the pattern matches
+     */
     message?: string;
 };
 /**
@@ -11,5 +17,5 @@ export type PatternConfig = {
  * Creates an ESLint rule that restricts imports based on their resolved paths.
  * Works with both ESM (import) and CommonJS (require) imports.
  */
-declare const _default: import("eslint").Rule.RuleModule;
-export default /** @type {import('eslint').Rule.RuleModule} */ _default;
+declare const _default: import('eslint').Rule.RuleModule;
+export default _default;

package/build/eslint/mui/rules/nodeEnvUtils.d.mts

@@ -21,3 +21,21 @@ export declare function isLiteralEq(node: import('estree').Node, value: string):
  * @returns {boolean}
  */
 export declare function isLiteralNeq(node: import('estree').Node, value: string): boolean;
+/**
+ * Checks if a BinaryExpression compares process.env.NODE_ENV with === or !==
+ * @param {import('estree').Node} node
+ * @returns {boolean}
+ */
+export declare function isNodeEnvBinaryComparison(node: import('estree').Node): boolean;
+/**
+ * Walks up the parent chain and checks if the node is inside an IfStatement
+ * whose test is a NODE_ENV binary comparison.
+ * If a callback is provided, it is called with the IfStatement and the direct
+ * child that leads to the node. The function returns true only when the callback
+ * returns true. Without a callback the function returns true when the node is
+ * inside any branch (consequent or alternate) of such an IfStatement.
+ * @param {import('eslint').Rule.Node} node
+ * @param {(ifStatement: import('estree').IfStatement & import('eslint').Rule.NodeParentExtension, child: import('eslint').Rule.Node) => boolean} [callback]
+ * @returns {boolean}
+ */
+export declare function isInsideNodeEnvCheck(node: import('eslint').Rule.Node, callback?: (ifStatement: import('estree').IfStatement & import('eslint').Rule.NodeParentExtension, child: import('eslint').Rule.Node) => boolean): boolean;

package/build/remark/config.d.mts

@@ -0,0 +1,43 @@
+import remarkGfm from 'remark-gfm';
+import remarkLint from 'remark-lint';
+/**
+ * Returns a remark preset wiring the MUI-authored remark-lint plugins together
+ * with a curated set of community plugins. Drop this into `.remarkrc.mjs`:
+ *
+ * ```js
+ * import { createRemarkConfig } from '@mui/internal-code-infra/remark';
+ * export default createRemarkConfig();
+ * ```
+ *
+ * Pass `overrides` to scope rule changes to a glob. Each entry's `rules` map
+ * is keyed by the rule name (the key used in `RULES`); `false` disables the
+ * rule for matching files, a settings tuple replaces its severity/options:
+ *
+ * ```js
+ * createRemarkConfig({
+ *   overrides: [
+ *     { files: 'docs/special/**', rules: { 'mui-no-space-in-links': false } },
+ *     { files: '**\/CHANGELOG.md', rules: { 'heading-style': ['warn', 'atx'] } },
+ *   ],
+ * });
+ * ```
+ *
+ * @param {Object} [options]
+ * @param {Array<{ files: string | string[], rules: Record<string, false | unknown[]> }>} [options.overrides]
+ */
+export declare function createRemarkConfig({ overrides }?: {
+    overrides?: Array<{
+        files: string | string[];
+        rules: Record<string, false | unknown[]>;
+    }>;
+}): {
+    settings: {
+        bullet: string;
+        emphasis: string;
+        fence: string;
+        listItemIndent: string;
+        resourceLink: boolean;
+        rule: string;
+    };
+    plugins: (any[] | typeof remarkGfm | typeof remarkLint)[];
+};

package/build/remark/createLintTester.d.mts

@@ -0,0 +1,10 @@
+/**
+ * @param {unknown} plugin
+ * @param {unknown} [options]
+ * @returns {(input: string) => Array<{ reason: string, line: number, column: number }>}
+ */
+export declare function createLintTester(plugin: unknown, options?: unknown): (input: string) => Array<{
+    reason: string;
+    line: number;
+    column: number;
+}>;

package/build/remark/firstBlockHeading.d.mts

@@ -0,0 +1,4 @@
+declare const remarkLintMuiFirstBlockHeading: import("unified-lint-rule").Plugin<import("mdast").Root, {
+    frontMatterTitle?: RegExp | false;
+} | undefined>;
+export default remarkLintMuiFirstBlockHeading;

package/build/remark/gitDiff.d.mts

@@ -0,0 +1,2 @@
+declare const remarkLintMuiGitDiff: import("unified-lint-rule").Plugin<import("mdast").Root, unknown>;
+export default remarkLintMuiGitDiff;

package/build/remark/noSpaceInLinks.d.mts

@@ -0,0 +1,2 @@
+declare const remarkLintMuiNoSpaceInLinks: import("unified-lint-rule").Plugin<import("mdast").Root, unknown>;
+export default remarkLintMuiNoSpaceInLinks;

package/build/remark/straightQuotes.d.mts

@@ -0,0 +1,2 @@
+declare const remarkLintMuiStraightQuotes: import("unified-lint-rule").Plugin<import("mdast").Root, unknown>;
+export default remarkLintMuiStraightQuotes;

package/build/remark/tableAlignment.d.mts

@@ -0,0 +1,2 @@
+declare const remarkLintMuiTableAlignment: import("unified-lint-rule").Plugin<import("mdast").Root, unknown>;
+export default remarkLintMuiTableAlignment;

package/build/remark/terminalLanguage.d.mts

@@ -0,0 +1,2 @@
+declare const remarkLintMuiTerminalLanguage: import("unified-lint-rule").Plugin<import("mdast").Root, unknown>;
+export default remarkLintMuiTerminalLanguage;

package/build/utils/babel.d.mts

@@ -15,7 +15,13 @@ export declare function cjsCopy({ from, to }: {
     to: string;
 }): Promise<void>;
 export type ErrorCodeMetadata = {
+    /**
+     * - The path where the error code file should be written.
+     */
     outputPath: string;
+    /**
+     * - The runtime module to replace the errors with.
+     */
     runtimeModule?: string;
 };
 /**
@@ -41,7 +47,7 @@ export type ErrorCodeMetadata = {
  * @param {string} options.babelRuntimeVersion - The version of @babel/runtime to use.
  * @returns {Promise<void>}
  */
-export declare function build({ cwd, sourceDir, outDir, babelRuntimeVersion, hasLargeFiles, bundle, pkgVersion, outExtension, optimizeClsx, removePropTypes, verbose, ignores, reactCompiler }: {
+export declare function build({ cwd, sourceDir, outDir, babelRuntimeVersion, hasLargeFiles, bundle, pkgVersion, outExtension, optimizeClsx, removePropTypes, verbose, ignores, reactCompiler, }: {
     verbose?: boolean;
     optimizeClsx?: boolean;
     removePropTypes?: boolean;

package/build/utils/build.d.mts

@@ -1,62 +1,85 @@
 export type BundleType = 'esm' | 'cjs';
-/**
- * @typedef {'esm' | 'cjs'} BundleType
- */
+export type BundleMeta = {
+    type: BundleType;
+    dir: string;
+    /**
+     * - The package.json condition this bundle maps to.
+     */
+    condition: 'import' | 'require';
+    outExtension: string;
+    typeOutExtension: string;
+};
+export declare const BASE_IGNORES: string[];
 /**
  * @param {BundleType} bundle
  * @param {Object} [options]
  * @param {boolean} [options.isType=false] - Whether to get the extension for type declaration files.
- * @param {boolean} [options.isFlat=false] - Whether to get the extension for a flat build structure.
  * @param {'module' | 'commonjs'} [options.packageType='commonjs'] - The package.json type field.
  * @returns {string}
  */
 export declare function getOutExtension(bundle: BundleType, options?: {
     isType?: boolean;
-    isFlat?: boolean;
     packageType?: 'module' | 'commonjs';
 }): string;
 /**
- * @param {Object} param0
- * @param {import('../cli/packageJson').PackageJson['exports']} param0.exports
- * @param {{type: BundleType; dir: string}[]} param0.bundles
- * @param {string} param0.outputDir
- * @param {string} param0.cwd
- * @param {boolean} [param0.addTypes]
- * @param {boolean} [param0.isFlat]
- * @param {'module' | 'commonjs'} [param0.packageType]
+ * @param {import('../cli/packageJson').PackageJson['exports']} packageExports
+ * @param {Object} options
+ * @param {BundleType[]} options.bundles
+ * @param {string} options.outputDir
+ * @param {string} options.cwd
+ * @param {boolean} [options.addTypes]
+ * @param {boolean} [options.expand] - Whether to enumerate glob patterns into concrete entries.
+ * @param {'module' | 'commonjs'} [options.packageType]
  */
-export declare function createPackageExports({ exports: packageExports, bundles, outputDir, cwd, addTypes, isFlat, packageType }: {
-    exports: import('../cli/packageJson').PackageJson['exports'];
-    bundles: {
-        type: BundleType;
-        dir: string;
-    }[];
+export declare function createPackageExports(packageExports: import('../cli/packageJson').PackageJson['exports'], { bundles, outputDir, cwd, addTypes, expand, packageType }: {
+    bundles: BundleType[];
     outputDir: string;
     cwd: string;
     addTypes?: boolean;
-    isFlat?: boolean;
+    expand?: boolean;
     packageType?: 'module' | 'commonjs';
 }): Promise<{
-    main?: string | undefined;
-    types?: string | undefined;
-    exports: import("../cli/packageJson").PackageJson.ExportConditions;
+    main?: string;
+    types?: string;
+    exports: import('../cli/packageJson').PackageJson.ExportConditions;
 }>;
 /**
- * @param {Object} param0
- * @param {import('../cli/packageJson').PackageJson['bin']} param0.bin
- * @param {{type: BundleType; dir: string}[]} param0.bundles
- * @param {string} param0.cwd
- * @param {boolean} [param0.isFlat]
- * @param {'module' | 'commonjs'} [param0.packageType]
+ * Generates the package.json `imports` field for the built package, rewriting
+ * internal subpath imports (keys starting with `#`) that point at source files
+ * into their built equivalents with `import`/`require`/`types` conditions.
+ *
+ * Mirrors {@link createPackageExports} but without the `.` / `package.json` /
+ * `main` / `types` index handling that only applies to public exports. Entries
+ * that resolve to bare specifiers (e.g. an external package) are passed through
+ * unchanged, since the `imports` field commonly aliases dependencies.
+ * @param {import('../cli/packageJson').PackageJson['imports']} packageImports
+ * @param {Object} options
+ * @param {BundleType[]} options.bundles
+ * @param {string} options.cwd
+ * @param {string} [options.outputDir] - Used to verify non-source passthrough paths exist in the build output.
+ * @param {boolean} [options.addTypes]
+ * @param {boolean} [options.expand] - Whether to enumerate glob patterns into concrete entries.
+ * @param {'module' | 'commonjs'} [options.packageType]
+ * @returns {Promise<import('../cli/packageJson').PackageJson.Imports | undefined>}
+ */
+export declare function createPackageImports(packageImports: import('../cli/packageJson').PackageJson['imports'], { bundles, cwd, outputDir, addTypes, expand, packageType }: {
+    bundles: BundleType[];
+    cwd: string;
+    outputDir?: string;
+    addTypes?: boolean;
+    expand?: boolean;
+    packageType?: 'module' | 'commonjs';
+}): Promise<import('../cli/packageJson').PackageJson.Imports | undefined>;
+/**
+ * @param {import('../cli/packageJson').PackageJson['bin']} bin
+ * @param {Object} options
+ * @param {BundleType[]} options.bundles
+ * @param {string} options.cwd
+ * @param {'module' | 'commonjs'} [options.packageType]
  */
-export declare function createPackageBin({ bin, bundles, cwd, isFlat, packageType }: {
-    bin: import('../cli/packageJson').PackageJson['bin'];
-    bundles: {
-        type: BundleType;
-        dir: string;
-    }[];
+export declare function createPackageBin(bin: import('../cli/packageJson').PackageJson['bin'], { bundles, cwd, packageType }: {
+    bundles: BundleType[];
     cwd: string;
-    isFlat?: boolean;
     packageType?: 'module' | 'commonjs';
 }): Promise<string | Record<string, string> | undefined>;
 /**
@@ -84,7 +107,6 @@ export declare function markFn<F extends () => Promise<any>>(label: string, fn:
  * @param {string} label
  */
 export declare function measureFn(label: string): PerformanceMeasure;
-export declare const BASE_IGNORES: string[];
 /**
  * A utility to map a function over an array of items in a worker pool.
  *

package/build/utils/extractErrorCodes.d.mts

@@ -1,6 +1,15 @@
 export type Args = {
+    /**
+     * - The output path to write the extracted error codes.
+     */
     errorCodesPath: string;
+    /**
+     * - List of package names to skip. By default, all workspace packages are considered.
+     */
     skip?: string[];
+    /**
+     * - The detection strategy to use when extracting error codes.
+     */
     detection?: import('@mui/internal-babel-plugin-minify-errors').Options['detection'];
 };
 /**

package/build/utils/git.d.mts

@@ -1,6 +1,15 @@
 export type RepoInfo = {
+    /**
+     * - Repository owner
+     */
     owner: string;
+    /**
+     * - Repository name
+     */
     repo: string;
+    /**
+     * - Remote name
+     */
     remoteName: string;
 };
 /**
@@ -20,3 +29,10 @@ export declare function getRepositoryInfo(cwd?: string): Promise<RepoInfo>;
  * @returns {Promise<string>} Current git commit SHA
  */
 export declare function getCurrentGitSha(): Promise<string>;
+/**
+ * Check whether a tag already exists on the origin remote
+ * @param {string} tagName - Tag name to check (e.g. `v1.2.3`)
+ * @param {string} [cwd=process.cwd()]
+ * @returns {Promise<boolean>} True if the tag exists on origin
+ */
+export declare function remoteGitTagExists(tagName: string, cwd?: string): Promise<boolean>;

package/build/utils/github.d.mts

@@ -7,9 +7,21 @@
  *
  */
 export type GitHubAppAuthenticationWithRefreshToken = {
+    /**
+     * - The access token
+     */
     token: string;
+    /**
+     * - ISO string when the access token expires
+     */
     expiresAt?: string;
+    /**
+     * - The refresh token
+     */
     refreshToken?: string;
+    /**
+     * - ISO string when the refresh token expires
+     */
     refreshTokenExpiresAt?: string;
 };
 /**
@@ -20,7 +32,7 @@ export type GitHubAppAuthenticationWithRefreshToken = {
  * @property {string} [refreshTokenExpiresAt] - ISO string when the refresh token expires
  */
 export declare function persistentAuthStrategy(): {
-    hook: (request: import("@octokit/types").RequestInterface<object>, route: string, parameters: import("@octokit/types").RequestParameters) => Promise<import("@octokit/types").OctokitResponse<any, number>>;
+    hook: (request: import('@octokit/types').RequestInterface, route: import('@octokit/types').Route, parameters: import('@octokit/types').RequestParameters) => Promise<import("@octokit/types").OctokitResponse<any, number>>;
 };
 /**
  * @param {Object} [options]