xo 2.0.0 → 2.0.2

package/dist/cli.d.ts

@@ -4,6 +4,10 @@ declare const cli: import("meow").Result<{
         type: "boolean";
         default: false;
     };
+    fixDryRun: {
+        type: "boolean";
+        default: false;
+    };
     reporter: {
         type: "string";
     };

package/dist/cli.js

@@ -16,6 +16,7 @@ const cli = meow(`
 
   Options
     --fix             Automagically fix issues
+    --fix-dry-run     Automagically fix issues without saving the changes to the file system
     --reporter        Reporter to use
     --space           Use space indent instead of tabs [Default: 2]
     --config          Path to a XO configuration file
@@ -46,6 +47,10 @@ const cli = meow(`
             type: 'boolean',
             default: false,
         },
+        fixDryRun: {
+            type: 'boolean',
+            default: false,
+        },
         reporter: {
             type: 'string',
         },
@@ -105,7 +110,7 @@ const baseXoConfigOptions = {
     react: cliOptions.react,
 };
 const linterOptions = {
-    fix: cliOptions.fix,
+    fix: cliOptions.fix || cliOptions.fixDryRun,
     cwd: (cliOptions.cwd && path.resolve(cliOptions.cwd)) ?? process.cwd(),
     quiet: cliOptions.quiet,
     ts: true,
@@ -114,7 +119,7 @@ const linterOptions = {
 // Make data types for `options.space` match those of the API
 if (typeof cliOptions.space === 'string') {
     cliOptions.space = cliOptions.space.trim();
-    if (/^\d+$/u.test(cliOptions.space)) {
+    if (/^\d+$/v.test(cliOptions.space)) {
         baseXoConfigOptions.space = Number.parseInt(cliOptions.space, 10);
     }
     else if (cliOptions.space === 'true') {
@@ -171,7 +176,7 @@ if (cliOptions.stdin) {
             await fs.writeFile(cliOptions.stdinFilename, stdin);
         }
     }
-    if (cliOptions.fix) {
+    if (linterOptions.fix) {
         const xo = new Xo(linterOptions, baseXoConfigOptions);
         const { results: [result] } = await xo.lintText(stdin, {
             filePath: cliOptions.stdinFilename,

package/dist/lib/resolve-config.js

@@ -29,7 +29,8 @@ export async function resolveXoConfig(options) {
         });
         options.filePath &&= path.resolve(options.cwd, options.filePath);
         const searchPath = options.filePath ?? options.cwd;
-        let { config: flatOptions = [], filepath: flatConfigPath = '', } = await (options.configPath
+        let { config: flatOptions = [], filepath: flatConfigPath = '', // eslint-disable-line @typescript-eslint/no-useless-default-assignment
+         } = await (options.configPath
             // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
             ? flatConfigExplorer.load(path.resolve(options.cwd, options.configPath))
             // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
@@ -41,6 +42,7 @@ export async function resolveXoConfig(options) {
         };
     }
     catch (error) {
+        // eslint-disable-next-line preserve-caught-error
         throw new AggregateError([error], 'Error resolving XO config, there is likely an issue with your config file. Please check the file for mistakes.');
     }
 }

package/dist/lib/rules/no-use-extend-native.d.ts

@@ -0,0 +1,3 @@
+import { type Rule } from 'eslint';
+declare const noUseExtendNativeRule: Rule.RuleModule;
+export default noUseExtendNativeRule;

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: /./v,
+        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/xo-to-eslint.js

@@ -107,12 +107,12 @@ export function xoToEslintConfig(flatXoConfig, { prettierOptions = {} } = {}) {
         if (xoConfigItem.react) {
             // Ensure the files applied to the React config are the same as the config they are derived from
             // TODO: Remove `fixupConfigRules` wrapping when eslint-config-xo-react supports ESLint 10 natively.
-            baseConfig.push({ ...fixupConfigRules(configReact)[0], files: eslintConfigItem.files, name: 'xo/react' });
+            baseConfig.push({ ...fixupConfigRules(configReact)[0], ...(eslintConfigItem.files ? { files: eslintConfigItem.files } : {}), name: 'xo/react' });
         }
         // Prettier should generally be the last config in the array
         if (xoConfigItem.prettier) {
             if (xoConfigItem.prettier === 'compat') {
-                baseConfig.push({ ...eslintConfigPrettier, files: eslintConfigItem.files });
+                baseConfig.push({ ...eslintConfigPrettier, ...(eslintConfigItem.files ? { files: eslintConfigItem.files } : {}) });
             }
             else {
                 // Validate that Prettier options match other `xoConfig` options.

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "xo",
-	"version": "2.0.0",
+	"version": "2.0.2",
 	"description": "JavaScript/TypeScript linter (ESLint wrapper) with great defaults",
 	"license": "MIT",
 	"repository": "xojs/xo",
@@ -33,6 +33,8 @@
 	"files": [
 		"dist/lib/*.js",
 		"dist/lib/*.d.ts",
+		"dist/lib/rules/*.js",
+		"dist/lib/rules/*.d.ts",
 		"dist/*.js",
 		"dist/*.d.ts"
 	],
@@ -74,7 +76,7 @@
 		"eslint": "^10.0.2",
 		"eslint-config-prettier": "^10.1.8",
 		"eslint-config-xo-react": "^0.29.0",
-		"eslint-config-xo-typescript": "^9.0.0",
+		"eslint-config-xo-typescript": "^10.0.0",
 		"eslint-formatter-pretty": "^7.0.0",
 		"eslint-plugin-ava": "^16.0.0",
 		"eslint-plugin-import-x": "^4.16.1",
@@ -101,11 +103,11 @@
 		"@types/micromatch": "^4.0.10",
 		"@types/node": "^25.2.1",
 		"@types/prettier": "^3.0.0",
-		"ava": "^6.4.1",
+		"ava": "^7.0.0",
 		"dedent": "^1.7.1",
 		"execa": "^9.6.1",
 		"husky": "^9.1.7",
-		"lint-staged": "^16.2.7",
+		"lint-staged": "^16.3.4",
 		"np": "^11.0.2",
 		"npm-package-json-lint": "^9.1.0",
 		"npm-package-json-lint-config-default": "^8.0.1",

package/readme.md

@@ -58,6 +58,7 @@ $ xo --help
 
 	Options
 		--fix             Automagically fix issues
+		--fix-dry-run     Automagically fix issues without saving the changes to the file system
 		--reporter        Reporter to use
 		--space           Use space indent instead of tabs [Default: 2]
 		--config          Path to a XO configuration file