xo 1.2.3 → 2.0.1

package/dist/lib/rules/no-use-extend-native.js

@@ -0,0 +1,386 @@
+const isPropertyContainer = (value) => typeof value === 'function' || (typeof value === 'object' && value !== null);
+const isIdentifierNode = (node) => node.type === 'Identifier' && 'name' in node && typeof node.name === 'string';
+const isLiteralNode = (node) => node.type === 'Literal';
+const isMemberExpressionNode = (node) => node.type === 'MemberExpression'
+    && 'computed' in node
+    && typeof node.computed === 'boolean'
+    && 'object' in node
+    && 'property' in node;
+const isBinaryExpressionNode = (node) => node.type === 'BinaryExpression'
+    && 'operator' in node
+    && typeof node.operator === 'string'
+    && 'left' in node
+    && 'right' in node;
+const isNewExpressionNode = (node) => node.type === 'NewExpression' && 'callee' in node;
+const createPropertyInfo = (value, extraProperties = []) => {
+    const all = new Set();
+    const callable = new Set();
+    for (const propertyName of extraProperties) {
+        all.add(propertyName);
+    }
+    for (let currentValue = value; isPropertyContainer(currentValue); currentValue = Object.getPrototypeOf(currentValue)) {
+        for (const propertyName of Object.getOwnPropertyNames(currentValue)) {
+            all.add(propertyName);
+            const descriptor = Object.getOwnPropertyDescriptor(currentValue, propertyName);
+            if (typeof descriptor?.value === 'function') {
+                callable.add(propertyName);
+            }
+        }
+    }
+    return {
+        all,
+        callable,
+    };
+};
+const emptyFunction = () => undefined;
+// Keep the checked native object list explicit so rule behavior stays predictable.
+const nativeObjectDefinitions = [
+    {
+        typeName: 'Array',
+        instance: [],
+        static: Array,
+        prototype: Array.prototype,
+    },
+    {
+        typeName: 'ArrayBuffer',
+        instance: new ArrayBuffer(0),
+        static: ArrayBuffer,
+        prototype: ArrayBuffer.prototype,
+    },
+    {
+        typeName: 'Boolean',
+        instance: Boolean.prototype,
+        static: Boolean,
+        prototype: Boolean.prototype,
+    },
+    {
+        typeName: 'DataView',
+        instance: new DataView(new ArrayBuffer(1)),
+        static: DataView,
+        prototype: DataView.prototype,
+    },
+    {
+        typeName: 'Date',
+        instance: new Date(),
+        static: Date,
+        prototype: Date.prototype,
+    },
+    {
+        typeName: 'Float32Array',
+        instance: new Float32Array(),
+        static: Float32Array,
+        prototype: Float32Array.prototype,
+    },
+    {
+        typeName: 'Float64Array',
+        instance: new Float64Array(),
+        static: Float64Array,
+        prototype: Float64Array.prototype,
+    },
+    {
+        typeName: 'Function',
+        instance: emptyFunction,
+        static: Function,
+        prototype: Function.prototype,
+    },
+    {
+        typeName: 'Int8Array',
+        instance: new Int8Array(),
+        static: Int8Array,
+        prototype: Int8Array.prototype,
+    },
+    {
+        typeName: 'Int16Array',
+        instance: new Int16Array(),
+        static: Int16Array,
+        prototype: Int16Array.prototype,
+    },
+    {
+        typeName: 'Int32Array',
+        instance: new Int32Array(),
+        static: Int32Array,
+        prototype: Int32Array.prototype,
+    },
+    {
+        typeName: 'Map',
+        instance: new Map(),
+        static: Map,
+        prototype: Map.prototype,
+    },
+    {
+        typeName: 'Number',
+        instance: Number.prototype,
+        static: Number,
+        prototype: Number.prototype,
+    },
+    {
+        typeName: 'Object',
+        instance: {},
+        static: Object,
+        prototype: Object.prototype,
+    },
+    {
+        typeName: 'Promise',
+        instance: Promise.resolve(),
+        static: Promise,
+        prototype: Promise.prototype,
+    },
+    {
+        typeName: 'RegExp',
+        instance: /./u,
+        static: RegExp,
+        prototype: RegExp.prototype,
+    },
+    {
+        typeName: 'Set',
+        instance: new Set(),
+        static: Set,
+        prototype: Set.prototype,
+    },
+    {
+        typeName: 'String',
+        instance: String.prototype,
+        instanceProperties: ['length'],
+        static: String,
+        prototype: String.prototype,
+    },
+    {
+        typeName: 'Uint8Array',
+        instance: new Uint8Array(),
+        static: Uint8Array,
+        prototype: Uint8Array.prototype,
+    },
+    {
+        typeName: 'Uint8ClampedArray',
+        instance: new Uint8ClampedArray(),
+        static: Uint8ClampedArray,
+        prototype: Uint8ClampedArray.prototype,
+    },
+    {
+        typeName: 'Uint16Array',
+        instance: new Uint16Array(),
+        static: Uint16Array,
+        prototype: Uint16Array.prototype,
+    },
+    {
+        typeName: 'Uint32Array',
+        instance: new Uint32Array(),
+        static: Uint32Array,
+        prototype: Uint32Array.prototype,
+    },
+    {
+        typeName: 'URL',
+        instance: new URL('https://example.com'),
+        static: URL,
+        prototype: URL.prototype,
+    },
+    {
+        typeName: 'URLSearchParams',
+        instance: new URLSearchParams(),
+        static: URLSearchParams,
+        prototype: URLSearchParams.prototype,
+    },
+    {
+        typeName: 'JSON',
+        static: JSON,
+    },
+    {
+        typeName: 'Math',
+        static: Math,
+    },
+    {
+        typeName: 'Reflect',
+        static: Reflect,
+    },
+];
+const nativeObjects = new Map();
+for (const nativeObjectDefinition of nativeObjectDefinitions) {
+    const nativeObjectInfo = {};
+    if (nativeObjectDefinition.instance) {
+        nativeObjectInfo.instance = createPropertyInfo(nativeObjectDefinition.instance, nativeObjectDefinition.instanceProperties);
+    }
+    if (nativeObjectDefinition.prototype) {
+        nativeObjectInfo.prototype = createPropertyInfo(nativeObjectDefinition.prototype);
+    }
+    if (nativeObjectDefinition.static) {
+        nativeObjectInfo.static = createPropertyInfo(nativeObjectDefinition.static);
+    }
+    nativeObjects.set(nativeObjectDefinition.typeName, nativeObjectInfo);
+}
+const getPropertyName = (memberExpression) => {
+    const { property } = memberExpression;
+    if (memberExpression.computed) {
+        return isLiteralNode(property) && typeof property.value === 'string' ? property.value : undefined;
+    }
+    return isIdentifierNode(property) ? property.name : undefined;
+};
+const resolveBinaryExpressionType = (binaryExpression) => {
+    if (binaryExpression.operator !== '+') {
+        return undefined;
+    }
+    const leftReference = resolveNativeObjectReference(binaryExpression.left);
+    const rightReference = resolveNativeObjectReference(binaryExpression.right);
+    if (leftReference?.usage !== 'instance' || rightReference?.usage !== 'instance') {
+        return undefined;
+    }
+    if (leftReference.typeName === 'String' || rightReference.typeName === 'String') {
+        return {
+            typeName: 'String',
+            usage: 'instance',
+        };
+    }
+    return undefined;
+};
+const resolveIdentifierReference = (node) => {
+    if (!nativeObjects.has(node.name)) {
+        return undefined;
+    }
+    return {
+        typeName: node.name,
+        usage: 'static',
+    };
+};
+const resolveLiteralReference = (node) => {
+    if (node.regex) {
+        return {
+            typeName: 'RegExp',
+            usage: 'instance',
+        };
+    }
+    if (typeof node.value === 'boolean') {
+        return {
+            typeName: 'Boolean',
+            usage: 'instance',
+        };
+    }
+    if (typeof node.value === 'number') {
+        return {
+            typeName: 'Number',
+            usage: 'instance',
+        };
+    }
+    if (typeof node.value === 'string') {
+        return {
+            typeName: 'String',
+            usage: 'instance',
+        };
+    }
+    return undefined;
+};
+const resolvePrototypeReference = (node) => {
+    if (getPropertyName(node) !== 'prototype' || !isIdentifierNode(node.object) || !nativeObjects.has(node.object.name)) {
+        return undefined;
+    }
+    return {
+        typeName: node.object.name,
+        usage: 'prototype',
+    };
+};
+const resolveNewExpressionReference = (node) => {
+    if (!isIdentifierNode(node.callee) || !nativeObjects.has(node.callee.name)) {
+        return undefined;
+    }
+    return {
+        typeName: node.callee.name,
+        usage: 'instance',
+    };
+};
+function resolveNativeObjectReference(node) {
+    if (!node) {
+        return undefined;
+    }
+    if (isMemberExpressionNode(node)) {
+        return resolvePrototypeReference(node);
+    }
+    if (isBinaryExpressionNode(node)) {
+        return resolveBinaryExpressionType(node);
+    }
+    if (isLiteralNode(node)) {
+        return resolveLiteralReference(node);
+    }
+    if (isIdentifierNode(node)) {
+        return resolveIdentifierReference(node);
+    }
+    if (isNewExpressionNode(node)) {
+        return resolveNewExpressionReference(node);
+    }
+    switch (node.type) {
+        case 'ArrayExpression': {
+            return {
+                typeName: 'Array',
+                usage: 'instance',
+            };
+        }
+        case 'ArrowFunctionExpression':
+        case 'FunctionExpression': {
+            return {
+                typeName: 'Function',
+                usage: 'instance',
+            };
+        }
+        case 'ObjectExpression': {
+            return {
+                typeName: 'Object',
+                usage: 'instance',
+            };
+        }
+        case 'TemplateLiteral': {
+            return {
+                typeName: 'String',
+                usage: 'instance',
+            };
+        }
+        default: {
+            return undefined;
+        }
+    }
+}
+const noUseExtendNativeRule = {
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Disallow relying on non-standard properties on native objects',
+        },
+        messages: {
+            unexpected: 'Avoid relying on extended native objects.',
+        },
+        schema: [],
+    },
+    create(context) {
+        return {
+            // eslint-disable-next-line @typescript-eslint/naming-convention
+            MemberExpression(node) {
+                const propertyName = getPropertyName(node);
+                if (!propertyName) {
+                    return;
+                }
+                const nativeObjectReference = resolveNativeObjectReference(node.object);
+                if (!nativeObjectReference) {
+                    return;
+                }
+                const propertyInfo = nativeObjects.get(nativeObjectReference.typeName)?.[nativeObjectReference.usage];
+                if (!propertyInfo) {
+                    return;
+                }
+                const isCall = node.parent.type === 'CallExpression' && node.parent.callee === node;
+                if (isCall) {
+                    if (!propertyInfo.callable.has(propertyName)) {
+                        context.report({
+                            node,
+                            messageId: 'unexpected',
+                        });
+                    }
+                    return;
+                }
+                if (!propertyInfo.all.has(propertyName)) {
+                    context.report({
+                        node,
+                        messageId: 'unexpected',
+                    });
+                }
+            },
+        };
+    },
+};
+export default noUseExtendNativeRule;
+//# sourceMappingURL=no-use-extend-native.js.map

package/dist/lib/types.d.ts

@@ -71,9 +71,11 @@ export type XoConfigItem = Simplify<XoConfigOptions & Omit<Linter.Config, 'files
     /**
     An array of glob patterns indicating the files that the configuration object should apply to. If not specified, the configuration object applies to all files.
 
+    Accepts a single glob string, an array of globs, or ESLint's native format where nested arrays create AND patterns.
+
     @see [Ignore Patterns](https://eslint.org/docs/latest/user-guide/configuring/configuration-files-new#excluding-files-with-ignores)
     */
-    files?: string | string[] | undefined;
+    files?: string | Array<string | string[]> | undefined;
     /**
     An array of glob patterns indicating the files that the configuration object should not apply to. If not specified, the configuration object applies to all files matched by files.
 

package/dist/lib/utils.d.ts

@@ -1,6 +1,6 @@
 import { type Linter } from 'eslint';
-import { type SetRequired } from 'type-fest';
 import { type XoConfigItem } from './types.js';
+export declare const typescriptParser: Linter.Parser | undefined;
 /**
 Convert a `xo` config item to an ESLint config item.
 
@@ -11,7 +11,7 @@ Files and rules will always be defined and all other ESLint config properties ar
 @param xoConfig
 @returns eslintConfig
 */
-export declare const xoToEslintConfigItem: (xoConfig: XoConfigItem) => SetRequired<Linter.Config, "rules" | "files">;
+export declare const xoToEslintConfigItem: (xoConfig: XoConfigItem) => Linter.Config;
 /**
 Function used to match files which should be included in the `tsconfig.json` files.
 
@@ -21,7 +21,7 @@ Function used to match files which should be included in the `tsconfig.json` fil
 @param ignores - The globs to ignore when matching the files.
 @returns An array of file paths that match the globs and do not match the ignores.
 */
-export declare const matchFilesForTsConfig: (cwd: string, files: string[], globs: string[], ignores: string[]) => string[];
+export declare const matchFilesForTsConfig: (cwd: string, files: string[] | undefined, globs: string[], ignores: string[]) => string[];
 /**
 Once a config is resolved, it is pre-processed to ensure that all properties are set correctly.
 

package/dist/lib/utils.js

@@ -3,6 +3,14 @@ import micromatch from 'micromatch';
 import arrify from 'arrify';
 import configXoTypescript from 'eslint-config-xo-typescript';
 import { allFilesGlob, jsExtensions, jsFilesGlob, } from './constants.js';
+const typescriptParserConfig = configXoTypescript.find(config => {
+    const languageOptions = config.languageOptions;
+    return languageOptions?.parser;
+});
+export const typescriptParser = typescriptParserConfig?.languageOptions?.parser;
+if (!typescriptParser) {
+    throw new Error('XO: Failed to locate TypeScript parser in eslint-config-xo-typescript');
+}
 /**
 Convert a `xo` config item to an ESLint config item.
 
@@ -17,8 +25,8 @@ export const xoToEslintConfigItem = (xoConfig) => {
     const { files, rules, space, prettier, ignores, semicolon, react, ..._xoConfig } = xoConfig;
     const eslintConfig = {
         ..._xoConfig,
-        files: arrify(xoConfig.files ?? allFilesGlob),
-        rules: xoConfig.rules ?? {},
+        ...(xoConfig.files ? { files: arrify(xoConfig.files) } : {}),
+        ...(xoConfig.rules ? { rules: xoConfig.rules } : {}),
     };
     eslintConfig.ignores &&= arrify(xoConfig.ignores);
     return eslintConfig;
@@ -32,7 +40,7 @@ Function used to match files which should be included in the `tsconfig.json` fil
 @param ignores - The globs to ignore when matching the files.
 @returns An array of file paths that match the globs and do not match the ignores.
 */
-export const matchFilesForTsConfig = (cwd, files, globs, ignores) => micromatch(files.map(file => path.normalize(path.relative(cwd, file))), 
+export const matchFilesForTsConfig = (cwd, files, globs, ignores) => micromatch(files?.map(file => path.normalize(path.relative(cwd, file))) ?? [], 
 // https://github.com/micromatch/micromatch/issues/217
 globs.map(glob => path.normalize(glob)), {
     dot: true,
@@ -47,11 +55,14 @@ This includes ensuring that user-defined properties can override XO defaults, an
 @param xoConfig - The flat XO config to pre-process.
 @returns The pre-processed flat XO config.
 */
+// eslint-disable-next-line complexity
 export const preProcessXoConfig = (xoConfig) => {
     const tsFilesGlob = [];
     const tsFilesIgnoresGlob = [];
     const processedConfig = [];
     for (const [idx, { ...config }] of xoConfig.entries()) {
+        const languageOptions = config.languageOptions;
+        const parserOptions = languageOptions?.parserOptions;
         // We can skip the first config  item, as it is the base config item.
         if (idx === 0) {
             processedConfig.push(config);
@@ -60,8 +71,10 @@ export const preProcessXoConfig = (xoConfig) => {
         // Use TS parser/plugin for JS files if the config contains TypeScript rules which are applied to JS files.
         // typescript-eslint rules set to "off" are ignored and not applied to JS files.
         if (config.rules
-            && !config.languageOptions?.parser
-            && !config.languageOptions?.parserOptions?.['project']
+            // eslint-disable-next-line @typescript-eslint/dot-notation
+            && !languageOptions?.['parser']
+            && parserOptions?.project === undefined
+            && parserOptions?.programs === undefined
             && !config.plugins?.['@typescript-eslint']) {
             const hasTsRules = Object.entries(config.rules).some(rulePair => {
                 // If its not a @typescript-eslint rule, we don't care
@@ -77,7 +90,7 @@ export const preProcessXoConfig = (xoConfig) => {
             if (hasTsRules) {
                 let isAppliedToJsFiles = false;
                 if (config.files) {
-                    const normalizedFiles = arrify(config.files).map(file => path.normalize(file));
+                    const normalizedFiles = arrify(config.files).flat().map(file => path.normalize(file));
                     // Strip the basename off any globs
                     const globs = normalizedFiles.map(file => micromatch.scan(file, { dot: true }).glob).filter(Boolean);
                     // Check if the files globs match a test file with a js extension
@@ -89,25 +102,27 @@ export const preProcessXoConfig = (xoConfig) => {
                     isAppliedToJsFiles = true;
                 }
                 if (isAppliedToJsFiles) {
-                    config.languageOptions ??= {};
+                    const updatedLanguageOptions = languageOptions
+                        ? { ...languageOptions, parser: typescriptParser }
+                        : { parser: typescriptParser };
+                    config.languageOptions = updatedLanguageOptions;
                     config.plugins ??= {};
                     config.plugins = {
                         ...config.plugins,
                         ...configXoTypescript[1]?.plugins,
                     };
-                    config.languageOptions.parser = configXoTypescript[1]?.languageOptions?.parser;
-                    tsFilesGlob.push(...arrify(config.files ?? allFilesGlob));
+                    tsFilesGlob.push(...arrify(config.files ?? allFilesGlob).flat());
                     tsFilesIgnoresGlob.push(...arrify(config.ignores));
                 }
             }
         }
-        // If a user sets the `parserOptions.project` or `projectService` or `tsconfigRootDir`, we need to ensure that the tsFilesGlob is set to exclude those files,
-        // as this indicates the user has opted out of the default TypeScript handling for those files.
-        if (config.languageOptions?.parserOptions?.['project'] !== undefined
-            || config.languageOptions?.parserOptions?.['projectService'] !== undefined
-            || config.languageOptions?.parserOptions?.['tsconfigRootDir'] !== undefined) {
+        // If the config sets `parserOptions.project`, `projectService`, `tsconfigRootDir`, or `programs`, treat those files as opt-out for XO's automatic program wiring.
+        if (parserOptions?.project !== undefined
+            || parserOptions?.projectService !== undefined
+            || parserOptions?.tsconfigRootDir !== undefined
+            || parserOptions?.programs !== undefined) {
             // The glob itself should NOT be negated
-            tsFilesIgnoresGlob.push(...arrify(config.files ?? allFilesGlob));
+            tsFilesIgnoresGlob.push(...arrify(config.files ?? allFilesGlob).flat());
         }
         processedConfig.push(config);
     }

package/dist/lib/xo-to-eslint.js

@@ -4,13 +4,57 @@ import arrify from 'arrify';
 import configReact from 'eslint-config-xo-react';
 import pluginPrettier from 'eslint-plugin-prettier';
 import eslintConfigPrettier from 'eslint-config-prettier';
+import { fixupConfigRules, fixupPluginRules } from '@eslint/compat';
 import { config } from './config.js';
 import { xoToEslintConfigItem } from './utils.js';
 /**
+Merge all plugins from every config into a single config entry at the start of the array, ensuring user-provided plugins take precedence. This avoids ESLint's flat config rejecting duplicate plugin names.
+*/
+const hoistPlugins = (configs, userPluginOverrides) => {
+    const plugins = {};
+    const configsWithoutPlugins = [];
+    for (const configItem of configs) {
+        const { plugins: configPlugins } = configItem;
+        if (!configPlugins) {
+            configsWithoutPlugins.push(configItem);
+            continue;
+        }
+        // ESLint flat config rejects duplicate plugin names, so merge all plugins into one config.
+        Object.assign(plugins, configPlugins);
+        const { plugins: _ignored, ...configWithoutPlugins } = configItem;
+        if (Object.keys(configWithoutPlugins).length > 0) {
+            configsWithoutPlugins.push(configWithoutPlugins);
+        }
+    }
+    for (const [pluginName, plugin] of userPluginOverrides) {
+        plugins[pluginName] = plugin;
+    }
+    if (Object.keys(plugins).length === 0) {
+        return configsWithoutPlugins;
+    }
+    return [
+        {
+            name: 'xo/plugins',
+            plugins,
+        },
+        ...configsWithoutPlugins,
+    ];
+};
+/**
 Takes a XO flat config and returns an ESlint flat config.
 */
 export function xoToEslintConfig(flatXoConfig, { prettierOptions = {} } = {}) {
     const baseConfig = [...config];
+    const userPluginOverrides = new Map();
+    for (const xoConfigItem of flatXoConfig ?? []) {
+        const { plugins } = xoConfigItem;
+        if (!plugins) {
+            continue;
+        }
+        for (const [pluginName, plugin] of Object.entries(plugins)) {
+            userPluginOverrides.set(pluginName, plugin);
+        }
+    }
     /**
     Since configs are merged and the last config takes precedence this means we need to handle both true AND false cases for each option. For example, we need to turn `prettier`, `space`, `semi`, etc. on or off for a specific file.
     */
@@ -35,6 +79,7 @@ export function xoToEslintConfig(flatXoConfig, { prettierOptions = {} } = {}) {
         */
         const eslintConfigItem = xoToEslintConfigItem(xoConfigItem);
         if (xoConfigItem.semicolon === false) {
+            eslintConfigItem.rules ??= {};
             eslintConfigItem.rules['@stylistic/semi'] = ['error', 'never'];
             eslintConfigItem.rules['@stylistic/semi-spacing'] = [
                 'error',
@@ -43,6 +88,7 @@ export function xoToEslintConfig(flatXoConfig, { prettierOptions = {} } = {}) {
         }
         if (xoConfigItem.space) {
             const spaces = typeof xoConfigItem.space === 'number' ? xoConfigItem.space : 2;
+            eslintConfigItem.rules ??= {};
             eslintConfigItem.rules['@stylistic/indent'] = [
                 'error',
                 spaces,
@@ -54,12 +100,14 @@ export function xoToEslintConfig(flatXoConfig, { prettierOptions = {} } = {}) {
         else if (xoConfigItem.space === false) {
             // If a user sets this to false for a small subset of files for some reason,
             // then we need to set them back to their original values.
+            eslintConfigItem.rules ??= {};
             eslintConfigItem.rules['@stylistic/indent'] = configXoTypescript[1]?.rules?.['@stylistic/indent'];
             eslintConfigItem.rules['@stylistic/indent-binary-ops'] = configXoTypescript[1]?.rules?.['@stylistic/indent-binary-ops'];
         }
         if (xoConfigItem.react) {
             // Ensure the files applied to the React config are the same as the config they are derived from
-            baseConfig.push({ ...configReact[0], files: eslintConfigItem.files });
+            // TODO: Remove `fixupConfigRules` wrapping when eslint-config-xo-react supports ESLint 10 natively.
+            baseConfig.push({ ...fixupConfigRules(configReact)[0], files: eslintConfigItem.files, name: 'xo/react' });
         }
         // Prettier should generally be the last config in the array
         if (xoConfigItem.prettier) {
@@ -68,7 +116,7 @@ export function xoToEslintConfig(flatXoConfig, { prettierOptions = {} } = {}) {
             }
             else {
                 // Validate that Prettier options match other `xoConfig` options.
-                /* eslint-disable-next-line */
+                // eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing
                 if ((xoConfigItem.semicolon && prettierOptions.semi === false) || (!xoConfigItem.semicolon && prettierOptions.semi === true)) {
                     throw new Error(`The Prettier config \`semi\` is ${prettierOptions.semi} while Xo \`semicolon\` is ${xoConfigItem.semicolon}, also check your .editorconfig for inconsistencies.`);
                 }
@@ -79,9 +127,10 @@ export function xoToEslintConfig(flatXoConfig, { prettierOptions = {} } = {}) {
                     throw new Error(`The Prettier config \`tabWidth\` is ${prettierOptions.tabWidth} while Xo \`space\` is ${xoConfigItem.space}, also check your .editorconfig for inconsistencies.`);
                 }
                 // Add Prettier plugin
+                // TODO: Remove `fixupPluginRules` wrapping when eslint-plugin-prettier supports ESLint 10 natively.
                 eslintConfigItem.plugins = {
                     ...eslintConfigItem.plugins,
-                    prettier: pluginPrettier,
+                    prettier: fixupPluginRules(pluginPrettier),
                 };
                 const prettierConfig = {
                     singleQuote: true,
@@ -96,6 +145,7 @@ export function xoToEslintConfig(flatXoConfig, { prettierOptions = {} } = {}) {
                 // Configure Prettier rules
                 const rulesWithPrettier = {
                     ...eslintConfigItem.rules,
+                    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
                     ...pluginPrettier.configs?.['recommended']?.rules,
                     // eslint-disable-next-line @typescript-eslint/naming-convention
                     'prettier/prettier': ['error', prettierConfig],
@@ -106,11 +156,16 @@ export function xoToEslintConfig(flatXoConfig, { prettierOptions = {} } = {}) {
         }
         else if (xoConfigItem.prettier === false) {
             // Turn Prettier off for a subset of files
+            eslintConfigItem.rules ??= {};
             eslintConfigItem.rules['prettier/prettier'] = 'off';
         }
+        if (Object.keys(eslintConfigItem).length === 0) {
+            continue;
+        }
         baseConfig.push(eslintConfigItem);
     }
-    return baseConfig;
+    // User plugins should always win, even if XO injects plugins later in the config list.
+    return hoistPlugins(baseConfig, userPluginOverrides);
 }
 export default xoToEslintConfig;
 //# sourceMappingURL=xo-to-eslint.js.map