A local-first personal finance app
lint: move last remaining native eslint rules to oxlint (create new alternatives) (#6468)
Matiss Janis Aboltinsf1faf456596e
diff --git a/.github/actions/ai-generated-release-notes/generate-summary.js b/.github/actions/ai-generated-release-notes/generate-summary.jsindex 056cf571ea..d05bcc6c58 100755--- a/.github/actions/ai-generated-release-notes/generate-summary.js+++ b/.github/actions/ai-generated-release-notes/generate-summary.js@@ -71,7 +71,7 @@ try {console.log('Generated summary:', summary);const result = {- summary: summary,+ summary,prNumber: prDetails.number,author: prDetails.author,};diff --git a/.github/actions/check-migrations.js b/.github/actions/check-migrations.jsindex 7049302724..e6954960dd 100644--- a/.github/actions/check-migrations.js+++ b/.github/actions/check-migrations.js@@ -35,14 +35,15 @@ function readMigrations(ref) {}spawnSync('git', ['fetch', 'origin', 'master']);-let masterMigrations = readMigrations('origin/master');-let headMigrations = readMigrations('HEAD');+const masterMigrations = readMigrations('origin/master');+const headMigrations = readMigrations('HEAD');-let latestMasterMigration = masterMigrations[masterMigrations.length - 1].date;-let newMigrations = headMigrations.filter(+const latestMasterMigration =+ masterMigrations[masterMigrations.length - 1].date;+const newMigrations = headMigrations.filter(migration => !masterMigrations.find(m => m.name === migration.name),);-let badMigrations = newMigrations.filter(+const badMigrations = newMigrations.filter(migration => migration.date <= latestMasterMigration,);diff --git a/.oxlintrc.json b/.oxlintrc.jsonindex 2b26a5b5b2..cab3adb82e 100644--- a/.oxlintrc.json+++ b/.oxlintrc.json@@ -25,6 +25,10 @@"actual/prefer-trans-over-t": "error","actual/prefer-if-statement": "warn","actual/prefer-logger-over-console": "error",+ "actual/object-shorthand-properties": "warn",+ "actual/prefer-const": "warn",+ "actual/no-anchor-tag": "warn",+ "actual/no-react-default-import": "warn",// JSX A11y rules"jsx-a11y/no-autofocus": [@@ -410,6 +414,12 @@"import/no-default-export": "off"}},+ {+ "files": ["packages/docs/**/*"],+ "rules": {+ "actual/no-anchor-tag": "off"+ }+ },// TODO: enable these{"files": [diff --git a/eslint.config.mjs b/eslint.config.mjsindex c6a8df47d5..cae81dc329 100644--- a/eslint.config.mjs+++ b/eslint.config.mjs@@ -47,22 +47,7 @@ export default defineConfig(perfectionist: pluginPerfectionist,},rules: {- 'no-restricted-properties': [- 'error',- {- object: 'require',- property: 'ensure',- message:- 'Please use import() instead. More info: https://facebook.github.io/create-react-app/docs/code-splitting',- },- {- object: 'System',- property: 'import',- message:- 'Please use import() instead. More info: https://facebook.github.io/create-react-app/docs/code-splitting',- },- ],-+ // TODO: https://github.com/oxc-project/oxc/issues/17076'perfectionist/sort-imports': ['warn',{@@ -93,26 +78,6 @@ export default defineConfig(newlinesBetween: 'always',},],-- 'object-shorthand': ['warn', 'properties'],-- 'no-restricted-syntax': [- 'warn',- {- // forbid React.* as they are legacy https://twitter.com/dan_abramov/status/1308739731551858689- selector:- ":matches(MemberExpression[object.name='React'], TSQualifiedName[left.name='React'])",- message:- 'Using default React import is discouraged, please use named exports directly instead.',- },- {- // forbid <a> in favor of <Link>- selector: 'JSXOpeningElement[name.name="a"]',- message: 'Using <a> is discouraged, please use <Link> instead.',- },- ],-- 'prefer-const': 'warn',},},{@@ -128,10 +93,4 @@ export default defineConfig('typescript-paths/absolute-import': ['error', { enableAlias: false }],},},- {- files: ['packages/docs/**/*'],- rules: {- 'no-restricted-syntax': 'off',- },- },);diff --git a/packages/desktop-client/src/components/Modals.tsx b/packages/desktop-client/src/components/Modals.tsxindex 96533f9c64..b3b682b765 100644--- a/packages/desktop-client/src/components/Modals.tsx+++ b/packages/desktop-client/src/components/Modals.tsx@@ -1,5 +1,5 @@// @ts-strict-ignore-import React, { useEffect } from 'react';+import React, { Fragment, useEffect } from 'react';import { useLocation } from 'react-router';import { send } from 'loot-core/platform/client/fetch';@@ -405,9 +405,7 @@ export function Modals() {}}).map((modal, idx) => (- <React.Fragment key={`${modalStack[idx].name}-${idx}`}>- {modal}- </React.Fragment>+ <Fragment key={`${modalStack[idx].name}-${idx}`}>{modal}</Fragment>));// fragment needed per TS typesdiff --git a/packages/desktop-client/src/components/common/Link.tsx b/packages/desktop-client/src/components/common/Link.tsxindex 6a93f14e59..4f1f473732 100644--- a/packages/desktop-client/src/components/common/Link.tsx+++ b/packages/desktop-client/src/components/common/Link.tsx@@ -52,7 +52,6 @@ const ExternalLink = ({}: ExternalLinkProps) => {return (// we can't use <ExternalLink /> here for obvious reasons- // eslint-disable-next-line no-restricted-syntax<ahref={to ?? ''}target="_blank"diff --git a/packages/desktop-client/src/notes/NotesTagFormatter.tsx b/packages/desktop-client/src/notes/NotesTagFormatter.tsxindex 61a7c90198..d2a04093ba 100644--- a/packages/desktop-client/src/notes/NotesTagFormatter.tsx+++ b/packages/desktop-client/src/notes/NotesTagFormatter.tsx@@ -1,4 +1,4 @@-import React from 'react';+import React, { Fragment } from 'react';import { useResponsive } from '@actual-app/components/hooks/useResponsive';@@ -35,9 +35,7 @@ export function NotesTagFormatter({switch (segment.type) {case 'text':- return (- <React.Fragment key={index}>{segment.content}</React.Fragment>- );+ return <Fragment key={index}>{segment.content}</Fragment>;case 'tag':if (isNarrowWidth) {diff --git a/packages/eslint-plugin-actual/lib/index.js b/packages/eslint-plugin-actual/lib/index.jsindex 01928269d4..96f4196e42 100644--- a/packages/eslint-plugin-actual/lib/index.js+++ b/packages/eslint-plugin-actual/lib/index.js@@ -8,5 +8,9 @@ module.exports = {typography: require('./rules/typography'),'prefer-if-statement': require('./rules/prefer-if-statement'),'prefer-logger-over-console': require('./rules/prefer-logger-over-console'),+ 'object-shorthand-properties': require('./rules/object-shorthand-properties'),+ 'prefer-const': require('./rules/prefer-const'),+ 'no-anchor-tag': require('./rules/no-anchor-tag'),+ 'no-react-default-import': require('./rules/no-react-default-import'),},};diff --git a/packages/eslint-plugin-actual/lib/rules/__tests__/no-anchor-tag.test.js b/packages/eslint-plugin-actual/lib/rules/__tests__/no-anchor-tag.test.jsnew file mode 100644index 0000000000..128ac7907c--- /dev/null+++ b/packages/eslint-plugin-actual/lib/rules/__tests__/no-anchor-tag.test.js@@ -0,0 +1,96 @@+//------------------------------------------------------------------------------+// Requirements+//------------------------------------------------------------------------------++import { runClassic } from 'eslint-vitest-rule-tester';++import * as rule from '../no-anchor-tag';++//------------------------------------------------------------------------------+// Tests+//------------------------------------------------------------------------------++runClassic(+ 'no-anchor-tag',+ rule,+ {+ valid: [+ // Link component usage+ `<Link variant="external" to="https://example.com">Click me</Link>`,+ `<Link variant="internal" to="/path">Internal link</Link>`,++ // Other JSX elements+ `<div>Content</div>`,+ `<span>Text</span>`,+ `<button>Click</button>`,++ // JSX with different casing+ `<A>Not an anchor</A>`,+ `<Anchor>Not an anchor</Anchor>`,++ // Self-closing tags+ `<img src="test.jpg" />`,+ `<br />`,+ ],++ invalid: [+ {+ code: '<a href="https://example.com">Link</a>',+ output: null,+ errors: [+ {+ messageId: 'useLink',+ type: 'JSXOpeningElement',+ },+ ],+ },+ {+ code: '<a href="/path" target="_blank">External</a>',+ output: null,+ errors: [+ {+ messageId: 'useLink',+ type: 'JSXOpeningElement',+ },+ ],+ },+ {+ code: '<a>Click here</a>',+ output: null,+ errors: [+ {+ messageId: 'useLink',+ type: 'JSXOpeningElement',+ },+ ],+ },+ {+ code: '<div><a href="/test">Link</a></div>',+ output: null,+ errors: [+ {+ messageId: 'useLink',+ type: 'JSXOpeningElement',+ },+ ],+ },+ {+ code: 'function Component() { return <a href="/">Home</a>; }',+ output: null,+ errors: [+ {+ messageId: 'useLink',+ type: 'JSXOpeningElement',+ },+ ],+ },+ ],+ },+ {+ parserOptions: {+ ecmaVersion: 2020,+ ecmaFeatures: { jsx: true },+ sourceType: 'module',+ },+ },+);diff --git a/packages/eslint-plugin-actual/lib/rules/__tests__/no-react-default-import.test.js b/packages/eslint-plugin-actual/lib/rules/__tests__/no-react-default-import.test.jsnew file mode 100644index 0000000000..4158fe0bf0--- /dev/null+++ b/packages/eslint-plugin-actual/lib/rules/__tests__/no-react-default-import.test.js@@ -0,0 +1,103 @@+//------------------------------------------------------------------------------+// Requirements+//------------------------------------------------------------------------------++import { runClassic } from 'eslint-vitest-rule-tester';++import * as rule from '../no-react-default-import';++//------------------------------------------------------------------------------+// Tests+//------------------------------------------------------------------------------++runClassic(+ 'no-react-default-import',+ rule,+ {+ valid: [+ // Named imports (correct usage)+ `import { Component, useState } from 'react';`,+ `import { Component as Comp, useState } from 'react';`,++ // Usage of named imports+ `const MyComponent = Component.extend({});`,+ `const [state, setState] = useState(0);`,++ // Other identifiers+ `const ReactLib = require('react-lib');`,+ `ReactLib.something();`,++ // Non-React member expressions+ `const obj = { React: 'test' };`,+ `obj.React.something();`,++ // JSX with Fragment (correct usage)+ `import { Fragment } from 'react';`,+ `const element = <Fragment>Test</Fragment>;`,+ ],++ invalid: [+ {+ code: 'const Component = React.Component;',+ output: null,+ errors: [+ {+ messageId: 'useNamedExport',+ type: 'MemberExpression',+ },+ ],+ },+ {+ code: 'const [state, setState] = React.useState(0);',+ output: null,+ errors: [+ {+ messageId: 'useNamedExport',+ type: 'MemberExpression',+ },+ ],+ },+ {+ code: 'class MyComponent extends React.Component {}',+ output: null,+ errors: [+ {+ messageId: 'useNamedExport',+ type: 'MemberExpression',+ },+ ],+ },+ {+ code: 'function test() { return React.createElement("div"); }',+ output: null,+ errors: [+ {+ messageId: 'useNamedExport',+ type: 'MemberExpression',+ },+ ],+ },+ {+ code: 'const element = <React.Fragment>Test</React.Fragment>;',+ output: null,+ errors: [+ {+ messageId: 'useNamedExport',+ type: 'JSXMemberExpression',+ },+ {+ messageId: 'useNamedExport',+ type: 'JSXMemberExpression',+ },+ ],+ },+ ],+ },+ {+ parserOptions: {+ ecmaVersion: 2020,+ ecmaFeatures: { jsx: true },+ sourceType: 'module',+ },+ },+);diff --git a/packages/eslint-plugin-actual/lib/rules/__tests__/object-shorthand-properties.test.js b/packages/eslint-plugin-actual/lib/rules/__tests__/object-shorthand-properties.test.jsnew file mode 100644index 0000000000..9f401c97ab--- /dev/null+++ b/packages/eslint-plugin-actual/lib/rules/__tests__/object-shorthand-properties.test.js@@ -0,0 +1,166 @@+//------------------------------------------------------------------------------+// Requirements+//------------------------------------------------------------------------------++import { runClassic } from 'eslint-vitest-rule-tester';++import * as rule from '../object-shorthand-properties';++//------------------------------------------------------------------------------+// Tests+//------------------------------------------------------------------------------++runClassic(+ 'object-shorthand-properties',+ rule,+ {+ valid: [+ // Already using shorthand+ `const obj = { foo };`,+ `const obj = { foo, bar };`,+ `const obj = { foo, bar, baz };`,++ // Different key and value names+ `const obj = { foo: bar };`,+ `const obj = { foo: bar.baz };`,+ `const obj = { foo: 123 };`,+ `const obj = { foo: 'bar' };`,+ `const obj = { foo: true };`,+ `const obj = { foo: null };`,+ `const obj = { foo: undefined };`,++ // Methods (should not be enforced)+ `const obj = { foo() {} };`,+ `const obj = { foo: function() {} };`,+ `const obj = { foo: () => {} };`,++ // Computed properties+ `const obj = { [foo]: foo };`,+ `const obj = { [foo]: bar };`,++ // String/number keys+ `const obj = { 'foo': foo };`,+ `const obj = { 123: 123 };`,++ // Nested objects (shorthand should still be enforced in nested objects)+ `const obj = { foo: { bar } };`,+ ],++ invalid: [+ {+ code: 'const obj = { foo: foo };',+ output: 'const obj = { foo };',+ errors: [+ {+ messageId: 'useShorthand',+ data: { key: 'foo' },+ type: 'Property',+ },+ ],+ },+ {+ code: 'const obj = { foo: foo, bar: bar };',+ output: 'const obj = { foo, bar };',+ errors: [+ {+ messageId: 'useShorthand',+ data: { key: 'foo' },+ type: 'Property',+ },+ {+ messageId: 'useShorthand',+ data: { key: 'bar' },+ type: 'Property',+ },+ ],+ },+ {+ code: 'const obj = { foo: foo, bar: baz };',+ output: 'const obj = { foo, bar: baz };',+ errors: [+ {+ messageId: 'useShorthand',+ data: { key: 'foo' },+ type: 'Property',+ },+ ],+ },+ {+ code: 'const obj = { a: a, b: b, c: c };',+ output: 'const obj = { a, b, c };',+ errors: [+ {+ messageId: 'useShorthand',+ data: { key: 'a' },+ type: 'Property',+ },+ {+ messageId: 'useShorthand',+ data: { key: 'b' },+ type: 'Property',+ },+ {+ messageId: 'useShorthand',+ data: { key: 'c' },+ type: 'Property',+ },+ ],+ },+ {+ code: 'function test() { return { x: x, y: y }; }',+ output: 'function test() { return { x, y }; }',+ errors: [+ {+ messageId: 'useShorthand',+ data: { key: 'x' },+ type: 'Property',+ },+ {+ messageId: 'useShorthand',+ data: { key: 'y' },+ type: 'Property',+ },+ ],+ },+ {+ code: 'const obj = { prop: prop, method() {} };',+ output: 'const obj = { prop, method() {} };',+ errors: [+ {+ messageId: 'useShorthand',+ data: { key: 'prop' },+ type: 'Property',+ },+ ],+ },+ {+ code: 'const obj = { foo: { bar: bar } };',+ output: 'const obj = { foo: { bar } };',+ errors: [+ {+ messageId: 'useShorthand',+ data: { key: 'bar' },+ type: 'Property',+ },+ ],+ },+ {+ code: 'const obj = { ...other, foo: foo };',+ output: 'const obj = { ...other, foo };',+ errors: [+ {+ messageId: 'useShorthand',+ data: { key: 'foo' },+ type: 'Property',+ },+ ],+ },+ ],+ },+ {+ parserOptions: {+ ecmaVersion: 2020,+ ecmaFeatures: { jsx: true },+ },+ },+);diff --git a/packages/eslint-plugin-actual/lib/rules/__tests__/prefer-const.test.js b/packages/eslint-plugin-actual/lib/rules/__tests__/prefer-const.test.jsnew file mode 100644index 0000000000..35c75edae9--- /dev/null+++ b/packages/eslint-plugin-actual/lib/rules/__tests__/prefer-const.test.js@@ -0,0 +1,162 @@+//------------------------------------------------------------------------------+// Requirements+//------------------------------------------------------------------------------++import { runClassic } from 'eslint-vitest-rule-tester';++import * as rule from '../prefer-const';++//------------------------------------------------------------------------------+// Tests+//------------------------------------------------------------------------------++runClassic(+ 'prefer-const',+ rule,+ {+ valid: [+ // Already using const+ `const x = 1;`,+ `const x = 1, y = 2;`,++ // let that gets reassigned+ `let x = 1; x = 2;`,+ `let x = 1; x++;`,+ `let x = 1; x += 1;`,+ `let x = 1; x--;`,+ `let x = 1; x -= 1;`,++ // let in for loops+ `for (let i = 0; i < 10; i++) {}`,+ `for (let item of items) {}`,+ `for (let item in items) {}`,++ // Destructuring with reassignment+ `let { x } = obj; x = 2;`,+ `let [x] = arr; x = 2;`,++ // Variables used before declaration (temporal dead zone)+ `let x; x = 1;`,++ // Destructuring assignment (valid use of let)+ `let id; ({ id } = obj);`,+ `let x, y; ({ x, y } = obj);`,+ `async function test() { let id; ({ id } = await someFunction()); }`,+ `let x, y; [x, y] = arr;`,+ `async function test() { let id; try { ({ id } = await func()); } catch {} }`,++ // Function parameters (not applicable)+ `function test(x) { return x; }`,++ // Variables in different scopes+ `const x = 1; function test() { let x = 2; x = 3; }`,+ ],++ invalid: [+ {+ code: 'let x = 1;',+ output: 'const x = 1;',+ errors: [+ {+ messageId: 'useConst',+ data: { name: 'x' },+ type: 'Identifier',+ },+ ],+ },+ {+ code: 'let x = 1, y = 2;',+ output: 'const x = 1, y = 2;',+ errors: [+ {+ messageId: 'useConst',+ data: { name: 'x' },+ type: 'Identifier',+ },+ {+ messageId: 'useConst',+ data: { name: 'y' },+ type: 'Identifier',+ },+ ],+ },+ {+ code: 'let x = 1; console.log(x);',+ output: 'const x = 1; console.log(x);',+ errors: [+ {+ messageId: 'useConst',+ data: { name: 'x' },+ type: 'Identifier',+ },+ ],+ },+ {+ code: 'let x = 1; let y = 2;',+ output: 'const x = 1; const y = 2;',+ errors: [+ {+ messageId: 'useConst',+ data: { name: 'x' },+ type: 'Identifier',+ },+ {+ messageId: 'useConst',+ data: { name: 'y' },+ type: 'Identifier',+ },+ ],+ },+ {+ code: 'function test() { let x = 1; return x; }',+ output: 'function test() { const x = 1; return x; }',+ errors: [+ {+ messageId: 'useConst',+ data: { name: 'x' },+ type: 'Identifier',+ },+ ],+ },+ {+ code: 'let { x } = obj;',+ output: 'const { x } = obj;',+ errors: [+ {+ messageId: 'useConst',+ data: { name: 'x' },+ type: 'Identifier',+ },+ ],+ },+ {+ code: 'let [x] = arr;',+ output: 'const [x] = arr;',+ errors: [+ {+ messageId: 'useConst',+ data: { name: 'x' },+ type: 'Identifier',+ },+ ],+ },+ {+ code: 'let x = 1, y = 2; y = 3;',+ output: 'let x = 1, y = 2; y = 3;',+ errors: [+ {+ messageId: 'useConst',+ data: { name: 'x' },+ type: 'Identifier',+ },+ ],+ },+ ],+ },+ {+ parserOptions: {+ ecmaVersion: 2020,+ ecmaFeatures: { jsx: true },+ },+ },+);diff --git a/packages/eslint-plugin-actual/lib/rules/no-anchor-tag.js b/packages/eslint-plugin-actual/lib/rules/no-anchor-tag.jsnew file mode 100644index 0000000000..ee4616236b--- /dev/null+++ b/packages/eslint-plugin-actual/lib/rules/no-anchor-tag.js@@ -0,0 +1,57 @@+//------------------------------------------------------------------------------+// Rule Definition+//------------------------------------------------------------------------------++/** @type {import('eslint').Rule.RuleModule} */+module.exports = {+ meta: {+ type: 'suggestion',+ docs: {+ description: 'Forbid usage of <a> tags in favor of <Link> component',+ },+ fixable: null,+ schema: [],+ messages: {+ useLink: 'Using <a> is discouraged, please use <Link> instead.',+ },+ },++ create(context) {+ //----------------------------------------------------------------------+ // Helpers+ //----------------------------------------------------------------------++ /**+ * Checks if the current file is the Link component itself+ * @returns {boolean}+ */+ function isLinkComponentFile() {+ const filename = context.getFilename();+ const normalizedFilename = filename.replace(/\\/g, '/');+ return normalizedFilename.includes(+ 'packages/desktop-client/src/components/common/Link.tsx',+ );+ }++ //----------------------------------------------------------------------+ // Public+ //----------------------------------------------------------------------++ return {+ JSXOpeningElement(node) {+ // Skip if this is the Link component file itself+ if (isLinkComponentFile()) {+ return;+ }++ // Check if the element name is "a"+ if (node.name.type === 'JSXIdentifier' && node.name.name === 'a') {+ context.report({+ node,+ messageId: 'useLink',+ });+ }+ },+ };+ },+};diff --git a/packages/eslint-plugin-actual/lib/rules/no-react-default-import.js b/packages/eslint-plugin-actual/lib/rules/no-react-default-import.jsnew file mode 100644index 0000000000..13ead79169--- /dev/null+++ b/packages/eslint-plugin-actual/lib/rules/no-react-default-import.js@@ -0,0 +1,86 @@+//------------------------------------------------------------------------------+// Rule Definition+//------------------------------------------------------------------------------++/** @type {import('eslint').Rule.RuleModule} */+module.exports = {+ meta: {+ type: 'suggestion',+ docs: {+ description:+ 'Forbid usage of default React import (React.*) in favor of named exports',+ },+ fixable: null,+ schema: [],+ messages: {+ useNamedExport:+ 'Using default React import is discouraged, please use named exports directly instead.',+ },+ },++ create(context) {+ //----------------------------------------------------------------------+ // Helpers+ //----------------------------------------------------------------------++ /**+ * Checks if a node is a React default import usage+ * @param {import('estree').Node} node+ * @returns {boolean}+ */+ function isReactDefaultImport(node) {+ // Check MemberExpression: React.Component, React.useState, etc.+ if (node.type === 'MemberExpression') {+ return (+ node.object.type === 'Identifier' && node.object.name === 'React'+ );+ }++ // Check TSQualifiedName: React.FC, React.ComponentType, etc. (TypeScript)+ if (node.type === 'TSQualifiedName') {+ return node.left.type === 'Identifier' && node.left.name === 'React';+ }++ return false;+ }++ //----------------------------------------------------------------------+ // Public+ //----------------------------------------------------------------------++ return {+ // Catch React.* member expressions (e.g., React.Component, React.useState)+ MemberExpression(node) {+ if (isReactDefaultImport(node)) {+ context.report({+ node,+ messageId: 'useNamedExport',+ });+ }+ },++ // Catch React.* in JSX (e.g., <React.Fragment>)+ JSXMemberExpression(node) {+ if (+ node.object.type === 'JSXIdentifier' &&+ node.object.name === 'React'+ ) {+ context.report({+ node,+ messageId: 'useNamedExport',+ });+ }+ },++ // Catch React.* TypeScript qualified names (e.g., React.FC, React.ComponentType)+ TSQualifiedName(node) {+ if (isReactDefaultImport(node)) {+ context.report({+ node,+ messageId: 'useNamedExport',+ });+ }+ },+ };+ },+};diff --git a/packages/eslint-plugin-actual/lib/rules/object-shorthand-properties.js b/packages/eslint-plugin-actual/lib/rules/object-shorthand-properties.jsnew file mode 100644index 0000000000..b403927ef9--- /dev/null+++ b/packages/eslint-plugin-actual/lib/rules/object-shorthand-properties.js@@ -0,0 +1,92 @@+/* @see https://eslint.org/docs/latest/rules/object-shorthand */+//------------------------------------------------------------------------------+// Rule Definition+//------------------------------------------------------------------------------++/** @type {import('eslint').Rule.RuleModule} */+module.exports = {+ meta: {+ type: 'suggestion',+ docs: {+ description:+ 'Enforce property shorthand syntax in object literals (properties only)',+ },+ fixable: 'code',+ schema: [],+ messages: {+ useShorthand:+ 'Expected property shorthand. Use `{{key}}` instead of `{{key}}: {{key}}`.',+ },+ },++ create(context) {+ const sourceCode = context.getSourceCode();++ //----------------------------------------------------------------------+ // Helpers+ //----------------------------------------------------------------------++ /**+ * Checks if a property can use shorthand syntax+ * @param {import('estree').Property} node+ * @returns {boolean}+ */+ function canUseShorthand(node) {+ // Only check properties (not methods)+ if (node.method) {+ return false;+ }++ // Key must be an identifier (not computed)+ if (node.key.type !== 'Identifier' || node.computed) {+ return false;+ }++ // Value must be an identifier with the same name as the key+ if (+ node.value.type !== 'Identifier' ||+ node.key.name !== node.value.name+ ) {+ return false;+ }++ // Already using shorthand+ if (node.shorthand) {+ return false;+ }++ return true;+ }++ /**+ * Creates a fixer to convert to shorthand+ * @param {import('estree').Property} node+ * @returns {import('eslint').Rule.ReportFixer}+ */+ function makeFixer(node) {+ return fixer => {+ const keyText = sourceCode.getText(node.key);+ return fixer.replaceText(node, keyText);+ };+ }++ //----------------------------------------------------------------------+ // Public+ //----------------------------------------------------------------------++ return {+ Property(node) {+ if (canUseShorthand(node)) {+ context.report({+ node,+ messageId: 'useShorthand',+ data: {+ key: node.key.name,+ },+ fix: makeFixer(node),+ });+ }+ },+ };+ },+};diff --git a/packages/eslint-plugin-actual/lib/rules/prefer-const.js b/packages/eslint-plugin-actual/lib/rules/prefer-const.jsnew file mode 100644index 0000000000..e5d5cca1e1--- /dev/null+++ b/packages/eslint-plugin-actual/lib/rules/prefer-const.js@@ -0,0 +1,368 @@+//------------------------------------------------------------------------------+// Rule Definition+//------------------------------------------------------------------------------++/** @type {import('eslint').Rule.RuleModule} */+module.exports = {+ meta: {+ type: 'suggestion',+ docs: {+ description:+ 'Require `const` declarations for variables that are never reassigned after declared',+ },+ fixable: 'code',+ schema: [],+ messages: {+ useConst: "'{{name}}' is never reassigned. Use 'const' instead.",+ },+ },++ create(context) {+ const sourceCode = context.getSourceCode();+ // Map of scope to Set of reassigned variable names in that scope+ const reassignedVariablesByScope = new Map();+ const letDeclarations = [];++ //----------------------------------------------------------------------+ // Helpers+ //----------------------------------------------------------------------++ /**+ * Gets the scope for a node+ * @param {import('estree').Node} node+ * @returns {import('eslint').Scope.Scope | null}+ */+ function getScope(node) {+ try {+ return sourceCode.getScope(node);+ } catch {+ return null;+ }+ }++ /**+ * Gets the variable name from an identifier node+ * @param {import('estree').Node} node+ * @returns {string | null}+ */+ function getVariableName(node) {+ if (node.type === 'Identifier') {+ return node.name;+ }+ return null;+ }++ /**+ * Marks a variable as reassigned in its scope+ * @param {string} name+ * @param {import('estree').Node} node+ */+ function markAsReassigned(name, node) {+ const scope = getScope(node);+ if (scope) {+ // Get the identifier being assigned+ let identifier = null;+ if (node.type === 'AssignmentExpression') {+ identifier = node.left.type === 'Identifier' ? node.left : null;+ } else if (node.type === 'UpdateExpression') {+ identifier =+ node.argument.type === 'Identifier' ? node.argument : null;+ }++ if (identifier) {+ // Use ESLint's scope analysis to find the variable being referenced+ // Search from the identifier's scope upward to find the variable+ let identifierScope = getScope(identifier);+ while (identifierScope) {+ const variable = identifierScope.variables.find(+ v => v.name === name,+ );+ if (variable) {+ // Found the variable - it's declared in identifierScope+ // (variables in a scope's variables array are declared in that scope)+ if (!reassignedVariablesByScope.has(identifierScope)) {+ reassignedVariablesByScope.set(identifierScope, new Set());+ }+ reassignedVariablesByScope.get(identifierScope).add(name);+ return;+ }+ identifierScope = identifierScope.upper;+ }+ }++ // Fallback: find variable in scope chain (for destructuring, etc.)+ let currentScope = scope;+ while (currentScope) {+ const variable = currentScope.variables.find(+ v => v.name === name && v.defs.length > 0,+ );+ if (variable) {+ // Variable is declared in currentScope (it's in currentScope.variables)+ if (!reassignedVariablesByScope.has(currentScope)) {+ reassignedVariablesByScope.set(currentScope, new Set());+ }+ reassignedVariablesByScope.get(currentScope).add(name);+ return;+ }+ currentScope = currentScope.upper;+ }+ }+ }++ /**+ * Checks if a variable is reassigned in its scope+ * @param {string} name+ * @param {import('eslint').Scope.Scope} variableScope+ * @returns {boolean}+ */+ function isReassignedInScope(name, variableScope) {+ const reassigned = reassignedVariablesByScope.get(variableScope);+ return reassigned ? reassigned.has(name) : false;+ }++ /**+ * Extracts all variable names from a pattern (handles destructuring)+ * @param {import('estree').Pattern} pattern+ * @returns {string[]}+ */+ function extractVariableNames(pattern) {+ const names = [];+ if (pattern.type === 'Identifier') {+ names.push(pattern.name);+ } else if (pattern.type === 'ObjectPattern') {+ for (const prop of pattern.properties) {+ if (prop.type === 'Property') {+ if (prop.value.type === 'Identifier') {+ names.push(prop.value.name);+ } else if (+ prop.value.type === 'ObjectPattern' ||+ prop.value.type === 'ArrayPattern'+ ) {+ names.push(...extractVariableNames(prop.value));+ }+ } else if (prop.type === 'RestElement') {+ names.push(...extractVariableNames(prop.argument));+ }+ }+ } else if (pattern.type === 'ArrayPattern') {+ for (const element of pattern.elements) {+ if (element) {+ if (element.type === 'Identifier') {+ names.push(element.name);+ } else if (+ element.type === 'ObjectPattern' ||+ element.type === 'ArrayPattern'+ ) {+ names.push(...extractVariableNames(element));+ } else if (element.type === 'RestElement') {+ names.push(...extractVariableNames(element.argument));+ }+ }+ }+ } else if (pattern.type === 'RestElement') {+ names.push(...extractVariableNames(pattern.argument));+ }+ return names;+ }++ /**+ * Creates a fixer to change `let` to `const`+ * @param {import('estree').VariableDeclaration} node+ * @returns {import('eslint').Rule.ReportFixer}+ */+ function makeFixer(node) {+ return fixer => {+ const letToken = sourceCode.getFirstToken(node, {+ filter: token => token.value === 'let',+ });+ if (letToken) {+ return fixer.replaceText(letToken, 'const');+ }+ return null;+ };+ }++ //----------------------------------------------------------------------+ // Public+ //----------------------------------------------------------------------++ return {+ // Track assignments to variables+ AssignmentExpression(node) {+ // Handle simple assignments: x = value+ const name = getVariableName(node.left);+ if (name) {+ markAsReassigned(name, node);+ } else {+ // Handle destructuring assignments: ({ x } = value) or [x] = value+ const patternNames = extractVariableNames(node.left);+ for (const patternName of patternNames) {+ markAsReassigned(patternName, node);+ }+ }+ },++ // Track update expressions (x++, x--, x += 1, etc.)+ UpdateExpression(node) {+ const name = getVariableName(node.argument);+ if (name) {+ markAsReassigned(name, node);+ }+ },++ // Track for loop initializers (let i = 0; i < 10; i++)+ 'ForStatement:exit'(node) {+ if (node.init && node.init.type === 'VariableDeclaration') {+ for (const declarator of node.init.declarations) {+ const name = getVariableName(declarator.id);+ if (name) {+ markAsReassigned(name, node);+ }+ }+ }+ if (node.update) {+ const name = getVariableName(node.update);+ if (name) {+ markAsReassigned(name, node);+ }+ }+ },++ 'ForInStatement:exit'(node) {+ if (node.left.type === 'VariableDeclaration') {+ for (const declarator of node.left.declarations) {+ const name = getVariableName(declarator.id);+ if (name) {+ markAsReassigned(name, node);+ }+ }+ }+ },++ 'ForOfStatement:exit'(node) {+ if (node.left.type === 'VariableDeclaration') {+ for (const declarator of node.left.declarations) {+ const name = getVariableName(declarator.id);+ if (name) {+ markAsReassigned(name, node);+ }+ }+ }+ },++ // Collect all let declarations+ VariableDeclaration(node) {+ if (node.kind === 'let') {+ letDeclarations.push(node);+ }+ },++ // Check all let declarations at the end+ 'Program:exit'() {+ for (const node of letDeclarations) {+ const nodeScope = getScope(node);+ if (!nodeScope) continue;++ // Collect all variables in this declaration with their scopes+ // Variables declared in a VariableDeclaration are in the scope that contains that declaration+ const allVariablesInDeclaration = new Map();+ for (const declarator of node.declarations) {+ const variableNames = extractVariableNames(declarator.id);+ for (const name of variableNames) {+ // Find the variable in nodeScope (where it should be declared)+ // Use the scope where we actually find the variable+ let variableScope = nodeScope;+ const variable = nodeScope.variables.find(v => v.name === name);+ if (variable) {+ // Variable found in nodeScope - use nodeScope+ variableScope = nodeScope;+ } else {+ // Variable not found in nodeScope, search upward (shouldn't happen, but be safe)+ let currentScope = nodeScope.upper;+ while (currentScope) {+ const foundVar = currentScope.variables.find(+ v => v.name === name,+ );+ if (foundVar) {+ variableScope = currentScope;+ break;+ }+ currentScope = currentScope.upper;+ }+ }+ allVariablesInDeclaration.set(name, variableScope);+ }+ }++ // Check if all variables in this declaration can be const+ const allCanBeConst = Array.from(+ allVariablesInDeclaration.entries(),+ ).every(([name, varScope]) => !isReassignedInScope(name, varScope));++ // Check each declarator+ for (const declarator of node.declarations) {+ const variableNames = extractVariableNames(declarator.id);++ for (const variableName of variableNames) {+ // Get the scope for this variable+ const variableScope = allVariablesInDeclaration.get(variableName);+ if (!variableScope) continue;++ // Skip if the variable is reassigned in its scope+ if (isReassignedInScope(variableName, variableScope)) {+ continue;+ }++ // Find the identifier node for this variable name+ let targetNode = declarator.id;+ if (declarator.id.type !== 'Identifier') {+ // For destructuring, find the specific identifier+ const findIdentifier = (pattern, name) => {+ if (pattern.type === 'Identifier' && pattern.name === name) {+ return pattern;+ }+ if (pattern.type === 'ObjectPattern') {+ for (const prop of pattern.properties) {+ if (prop.type === 'Property') {+ const found = findIdentifier(prop.value, name);+ if (found) return found;+ } else if (prop.type === 'RestElement') {+ const found = findIdentifier(prop.argument, name);+ if (found) return found;+ }+ }+ }+ if (pattern.type === 'ArrayPattern') {+ for (const element of pattern.elements) {+ if (element) {+ const found = findIdentifier(element, name);+ if (found) return found;+ }+ }+ }+ if (pattern.type === 'RestElement') {+ return findIdentifier(pattern.argument, name);+ }+ return null;+ };+ targetNode =+ findIdentifier(declarator.id, variableName) || declarator.id;+ }++ // Report for this variable+ // Only provide a fix if all variables in the declaration can be const+ context.report({+ node: targetNode,+ messageId: 'useConst',+ data: {+ name: variableName,+ },+ fix: allCanBeConst ? makeFixer(node) : null,+ });+ }+ }+ }+ },+ };+ },+};diff --git a/upcoming-release-notes/6468.md b/upcoming-release-notes/6468.mdnew file mode 100644index 0000000000..67e9b6e662--- /dev/null+++ b/upcoming-release-notes/6468.md@@ -0,0 +1,6 @@+---+category: Maintenance+authors: [MatissJanis]+---++lint: create new custom rules for eslint rules that are not in oxlint