[ZEPPELIN-6372] Reimplement custom TSLint rules as ESLint rules

zeppelin-web-angular/eslint-rules/constructor-params-order.js

@@ -0,0 +1,173 @@
+/*
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ESLint reimplementation of the former custom TSLint `constructor-params-order`
+// rule (ZEPPELIN-6301). Enforces the constructor parameter order
+// public -> protected -> private (-> none -> optional) for a consistent New UI
+// constructor style. ESLint replaces TSLint under ZEPPELIN-6372.
+
+'use strict';
+
+const RANK = { public: 0, protected: 1, private: 2, none: 3, optional: 4 };
+
+/**
+ * Collect decorators attached to a (possibly parameter-property) parameter node.
+ * @param {any} param
+ * @returns {any[]}
+ */
+function getDecorators(param) {
+  if (Array.isArray(param.decorators) && param.decorators.length > 0) {
+    return param.decorators;
+  }
+  // TSParameterProperty wraps the real parameter in `.parameter`.
+  if (param.parameter && Array.isArray(param.parameter.decorators)) {
+    return param.parameter.decorators;
+  }
+  return [];
+}
+
+/**
+ * True when the parameter is optional -- either annotated with `@Optional()`
+ * (Angular DI) or declared with a `?` question token.
+ * @param {any} param
+ * @returns {boolean}
+ */
+function isOptional(param) {
+  const hasOptionalDecorator = getDecorators(param).some(decorator => {
+    let expr = decorator.expression;
+    if (expr && expr.type === 'CallExpression') {
+      expr = expr.callee;
+    }
+    return expr && expr.type === 'Identifier' && expr.name === 'Optional';
+  });
+  if (hasOptionalDecorator) {
+    return true;
+  }
+  const inner = param.type === 'TSParameterProperty' ? param.parameter : param;
+  return !!(inner && inner.optional);
+}
+
+/**
+ * Map a constructor parameter to its accessibility rank.
+ * @param {any} param
+ * @returns {number}
+ */
+function getRank(param) {
+  if (isOptional(param)) {
+    return RANK.optional;
+  }
+  if (param.type === 'TSParameterProperty') {
+    // A parameter property with no explicit accessibility (e.g. `readonly x`)
+    // is implicitly public.
+    return RANK[param.accessibility || 'public'];
+  }
+  return RANK.none;
+}
+
+/**
+ * Source range of a parameter's "content": the parameter itself plus its
+ * leading decorators/comments and any trailing comment that sits before the
+ * following comma. Reordering moves these content ranges between fixed slots
+ * (keeping the original commas and whitespace in place), so comments travel
+ * with their parameter -- the same guarantee the original TSLint fixer gave by
+ * slicing from getFullStart() to getFullStart().
+ * @param {any} param
+ * @param {import('eslint').SourceCode} sourceCode
+ * @returns {[number, number]}
+ */
+function getContentRange(param, sourceCode) {
+  let start = param.range[0];
+  let headNode = param;
+  for (const decorator of getDecorators(param)) {
+    if (decorator.range[0] < start) {
+      start = decorator.range[0];
+      headNode = decorator;
+    }
+  }
+  const leading = sourceCode.getCommentsBefore(headNode);
+  if (leading.length > 0 && leading[0].range[0] < start) {
+    start = leading[0].range[0];
+  }
+  let end = param.range[1];
+  const nextToken = sourceCode.getTokenAfter(param);
+  for (const comment of sourceCode.getCommentsAfter(param)) {
+    if (!nextToken || comment.range[1] <= nextToken.range[0]) {
+      end = Math.max(end, comment.range[1]);
+    }
+  }
+  return [start, end];
+}
+
+/** @type {import('eslint').Rule.RuleModule} */
+module.exports = {
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description: 'Enforce constructor parameter order: public, protected, private'
+    },
+    fixable: 'code',
+    schema: [],
+    messages: {
+      order: 'Constructor parameters should be ordered: public, protected, private'
+    }
+  },
+
+  create(context) {
+    const sourceCode = context.sourceCode || context.getSourceCode();
+
+    /**
+     * @param {any} node MethodDefinition with kind === 'constructor'
+     */
+    function checkConstructor(node) {
+      const params = node.value.params;
+      if (!params || params.length <= 1) {
+        return;
+      }
+
+      const ranks = params.map(getRank);
+      const inOrder = ranks.every((rank, i) => i === 0 || ranks[i - 1] <= rank);
+      if (inOrder) {
+        return;
+      }
+
+      context.report({
+        node,
+        messageId: 'order',
+        fix(fixer) {
+          const text = sourceCode.getText();
+          const ranges = params.map(p => getContentRange(p, sourceCode));
+          // Stable sort by rank preserves the original relative order within a
+          // group, matching the previous TSLint behaviour.
+          const order = params.map((_, i) => i).sort((a, b) => ranks[a] - ranks[b]);
+
+          // Drop the sorted parameter content into the fixed slots, keeping the
+          // original separators (commas, whitespace, indentation) between slots
+          // untouched. Only the parameter text moves, so formatting and inter-
+          // parameter comments are preserved.
+          let out = '';
+          for (let slot = 0; slot < params.length; slot++) {
+            const src = ranges[order[slot]];
+            out += text.slice(src[0], src[1]);
+            if (slot < params.length - 1) {
+              out += text.slice(ranges[slot][1], ranges[slot + 1][0]);
+            }
+          }
+          return fixer.replaceTextRange([ranges[0][0], ranges[params.length - 1][1]], out);
+        }
+      });
+    }
+
+    return {
+      'MethodDefinition[kind="constructor"]': checkConstructor
+    };
+  }
+};

zeppelin-web-angular/eslint-rules/constructor-params-order.test.js

@@ -0,0 +1,84 @@
+/*
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// Regression suite for the constructor-params-order fixer. It rewrites source
+// files unattended via lint-staged on every commit, so the tricky reordering
+// cases (comments, multi-line) are locked down here. Run with
+// `npm run test:eslint-rules` (Node's built-in runner, no extra deps).
+
+'use strict';
+
+const test = require('node:test');
+const { RuleTester } = require('eslint');
+const tsParser = require('@typescript-eslint/parser');
+const rule = require('./constructor-params-order');
+
+const ruleTester = new RuleTester({
+  languageOptions: { parser: tsParser, ecmaVersion: 2022, sourceType: 'module' }
+});
+
+test('constructor-params-order', () => {
+  ruleTester.run('constructor-params-order', rule, {
+    valid: [
+      'class A { constructor(public a: X, protected b: Y, private c: Z) {} }',
+      'class A { constructor(private a: X) {} }',
+      'class A { constructor() {} }',
+      // optional (@Optional() / question token) ranks last, so these are ordered
+      'class A { constructor(public a: X, private c: Z, @Optional() private d: W) {} }',
+      'class A { constructor(private a: X, @Optional() @Inject(T) public b: Y) {} }',
+      'class A { constructor(private a: X, b?: Y) {} }',
+      // a `readonly`-only parameter property is implicitly public, so it ranks first
+      'class A { constructor(readonly a: X, private b: Y) {} }'
+    ],
+    invalid: [
+      {
+        code: 'class A { constructor(private c: Z, public a: X) {} }',
+        output: 'class A { constructor(public a: X, private c: Z) {} }',
+        errors: [{ messageId: 'order' }]
+      },
+      {
+        code: 'class A { constructor(private c: Z, protected b: Y, public a: X) {} }',
+        output: 'class A { constructor(public a: X, protected b: Y, private c: Z) {} }',
+        errors: [{ messageId: 'order' }]
+      },
+      {
+        code: 'class A { constructor(@Optional() private a: X, public b: Y) {} }',
+        output: 'class A { constructor(public b: Y, @Optional() private a: X) {} }',
+        errors: [{ messageId: 'order' }]
+      },
+      // a trailing comment before the comma must travel with its parameter
+      {
+        code: 'class A { constructor(private b: B /* injected lazily */, public a: A) {} }',
+        output: 'class A { constructor(public a: A, private b: B /* injected lazily */) {} }',
+        errors: [{ messageId: 'order' }]
+      },
+      // multi-line: original commas / indentation are preserved
+      {
+        code: 'class A {\n  constructor(\n    private c: Z,\n    public a: X\n  ) {}\n}',
+        output: 'class A {\n  constructor(\n    public a: X,\n    private c: Z\n  ) {}\n}',
+        errors: [{ messageId: 'order' }]
+      },
+      // a leading block comment stays attached to its parameter
+      {
+        code: 'class A {\n  constructor(\n    private a: A,\n    /* keep */ public b: B\n  ) {}\n}',
+        output: 'class A {\n  constructor(\n    /* keep */ public b: B,\n    private a: A\n  ) {}\n}',
+        errors: [{ messageId: 'order' }]
+      },
+      // a `readonly`-only parameter property is public and must precede private
+      {
+        code: 'class A { constructor(private a: A, readonly b: B) {} }',
+        output: 'class A { constructor(readonly b: B, private a: A) {} }',
+        errors: [{ messageId: 'order' }]
+      }
+    ]
+  });
+});

zeppelin-web-angular/eslint-rules/index.js

@@ -0,0 +1,24 @@
+/*
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// Local ESLint plugin for the project's Angular-specific constructor parameter
+// ordering rule, reimplemented from the former custom TSLint rule
+// (ZEPPELIN-6301 / ZEPPELIN-6372). The alphabetical public-api.ts export sort
+// (ZEPPELIN-6325) is delegated to eslint-plugin-perfectionist instead.
+
+'use strict';
+
+module.exports = {
+  rules: {
+    'constructor-params-order': require('./constructor-params-order')
+  }
+};

zeppelin-web-angular/eslint.config.js

@@ -19,6 +19,10 @@ const importPlugin = require('eslint-plugin-import');
 const jsdoc = require('eslint-plugin-jsdoc');
 const preferArrow = require('eslint-plugin-prefer-arrow');
 const prettier = require('eslint-config-prettier');
+// Local plugin: the Angular-specific constructor-params-order rule reimplemented
+// from the former TSLint rule (ZEPPELIN-6372).
+const localRules = require('./eslint-rules');
+const perfectionist = require('eslint-plugin-perfectionist');
 
 module.exports = tseslint.config(
   {
@@ -50,7 +54,8 @@ module.exports = tseslint.config(
       '@typescript-eslint': tseslint.plugin,
       import: importPlugin,
       jsdoc,
-      'prefer-arrow': preferArrow
+      'prefer-arrow': preferArrow,
+      local: localRules
     },
     rules: {
       '@angular-eslint/component-selector': [
@@ -104,6 +109,11 @@ module.exports = tseslint.config(
       '@typescript-eslint/no-unsafe-function-type': 'error',
 
       '@typescript-eslint/member-ordering': 'warn',
+
+      // Custom rule (reimplemented from TSLint, ZEPPELIN-6372): keep the New UI
+      // constructor parameter order consistent as public -> protected -> private.
+      'local/constructor-params-order': 'error',
+
       '@typescript-eslint/explicit-member-accessibility': ['off', { accessibility: 'explicit' }],
       '@typescript-eslint/no-explicit-any': 'error',
       '@typescript-eslint/no-floating-promises': 'off',
@@ -146,6 +156,16 @@ module.exports = tseslint.config(
       '@angular-eslint/directive-selector': ['error', { type: 'attribute', prefix: 'lib', style: 'camelCase' }]
     }
   },
+  {
+    // ZEPPELIN-6325 / ZEPPELIN-6372: keep public-api.ts barrels alphabetically
+    // ordered by module specifier. Delegated to eslint-plugin-perfectionist
+    // rather than owning a custom statement-reordering fixer.
+    files: ['**/public-api.ts'],
+    plugins: { perfectionist },
+    rules: {
+      'perfectionist/sort-exports': 'error'
+    }
+  },
   {
     files: ['**/*.html'],
     // == legacy `plugin:@angular-eslint/template/recommended`