chore(ci): enable max params lint rule

Signed-off-by: Cory Rylan <crylan@nvidia.com>

Author: coryrylan

projects/core/src/internal/controllers/keynav-grid.controller.ts

@@ -165,12 +165,11 @@ function getGridDelta(code: KeynavCode | string, dir: string): { dx: number; dy:
 
 function applyGridHomeEnd(
   code: KeynavCode | string,
-  x: number,
-  y: number,
-  columnCount: number,
-  rowCount: number,
-  ctrlKey: boolean
+  position: { x: number; y: number },
+  bounds: { columnCount: number; rowCount: number; ctrlKey: boolean }
 ) {
+  const { x, y } = position;
+  const { columnCount, rowCount, ctrlKey } = bounds;
   if (code === KeynavCode.End) {
     return { x: columnCount, y: ctrlKey ? rowCount : y };
   }
@@ -201,7 +200,7 @@ export function getNextKeyGridItem(
     x = Math.max(0, Math.min(columnCount, x + delta.dx));
     y = Math.max(0, Math.min(rowCount, y + delta.dy));
   } else {
-    ({ x, y } = applyGridHomeEnd(config.code, x, y, columnCount, rowCount, config.ctrlKey));
+    ({ x, y } = applyGridHomeEnd(config.code, { x, y }, { columnCount, rowCount, ctrlKey: config.ctrlKey }));
   }
 
   return { x, y };

projects/core/src/internal/controllers/keynav-list.controller.ts

@@ -149,7 +149,8 @@ function resolveSpecialKey(code: KeynavCode): 'home' | 'end' | 'pageup' | 'paged
   return null;
 }
 
-function navigateWithLoop(current: number, limit: number, step: number, loop: boolean | undefined) {
+function navigateWithLoop(current: number, step: number, options: { limit: number; loop: boolean | undefined }) {
+  const { limit, loop } = options;
   const next = current + step;
   if (next >= 0 && next <= limit) return next;
   return loop ? (step < 0 ? limit : 0) : current;
@@ -163,10 +164,10 @@ export function getNextKeyListItem(item: HTMLElement, items: HTMLElement[], conf
 
   switch (direction ?? resolveSpecialKey(config.code)) {
     case 'backward':
-      next = navigateWithLoop(next, itemCount, -1, config.loop);
+      next = navigateWithLoop(next, -1, { limit: itemCount, loop: config.loop });
       break;
     case 'forward':
-      next = navigateWithLoop(next, itemCount, 1, config.loop);
+      next = navigateWithLoop(next, 1, { limit: itemCount, loop: config.loop });
       break;
     case 'end':
       next = itemCount;

projects/core/src/sparkline/sparkline.ts

@@ -154,20 +154,19 @@ export class Sparkline extends LitElement implements DataElement<number[]> {
   }
 
   #renderLineVariant(width: number, height: number) {
-    const domain = calculateDomain(this.validData, this.min, this.max);
+    const domain = calculateDomain(this.validData, { explicitMin: this.min, explicitMax: this.max });
     if (!domain) return nothing;
 
-    const baselineY = valueToY(0, domain.min, domain.max);
+    const baselineY = valueToY(0, domain);
     const drawZeroLine = domain.min < 0 && domain.max > 0;
 
-    const plotPoints = toPlotPoints(this.validData, domain.min, domain.max, width);
-    const symbolIndices = calculateSymbolIndices(
-      this.validData,
-      this.denoteFirst,
-      this.denoteLast,
-      this.denoteMin,
-      this.denoteMax
-    );
+    const plotPoints = toPlotPoints(this.validData, domain, { width });
+    const symbolIndices = calculateSymbolIndices(this.validData, {
+      first: this.denoteFirst,
+      last: this.denoteLast,
+      min: this.denoteMin,
+      max: this.denoteMax
+    });
     const interpolation = toInterpolation(this.interpolation);
 
     const linePath = toLinePath(plotPoints, interpolation, width);
@@ -235,12 +234,16 @@ export class Sparkline extends LitElement implements DataElement<number[]> {
   }
 
   #renderColumn(width: number, height: number) {
-    const domain = calculateDomain(this.validData, this.min, this.max, true);
+    const domain = calculateDomain(this.validData, {
+      explicitMin: this.min,
+      explicitMax: this.max,
+      includeZero: true
+    });
     if (!domain) return nothing;
 
-    const baselineY = valueToY(0, domain.min, domain.max);
+    const baselineY = valueToY(0, domain);
     const showZeroLine = domain.min < 0 && domain.max > 0;
-    const plotPoints = toPlotPoints(this.validData, domain.min, domain.max, width);
+    const plotPoints = toPlotPoints(this.validData, domain, { width });
     const rects = toColumnRects(plotPoints, baselineY, width);
 
     return svg`
@@ -257,7 +260,7 @@ export class Sparkline extends LitElement implements DataElement<number[]> {
   #renderWinLoss(baselineY: number, width: number, height: number) {
     if (this.validData.length === 0) return nothing;
 
-    const rects = toWinLossRects(this.validData, baselineY, width, height);
+    const rects = toWinLossRects(this.validData, baselineY, { width, height });
 
     return svg`
       <svg viewBox="0 0 ${width} ${height}" preserveAspectRatio="xMidYMid meet" aria-hidden="true">

projects/core/src/sparkline/sparkline.utils.test.ts

@@ -47,28 +47,28 @@ describe('sparkline.utils', () => {
     });
 
     it('includes zero in the domain when includeZero is true', () => {
-      expect(calculateDomain([10, 20, 15], undefined, undefined, true)).toEqual({ min: 0, max: 20 });
+      expect(calculateDomain([10, 20, 15], { includeZero: true })).toEqual({ min: 0, max: 20 });
     });
 
     it('returns the observed range when data includes negatives', () => {
       expect(calculateDomain([5, -3, 2])).toEqual({ min: -3, max: 5 });
     });
 
     it('uses explicit min/max overrides even when data exceeds those bounds', () => {
-      expect(calculateDomain([-100, 50, 200], -10, 10)).toEqual({ min: -10, max: 10 });
-      expect(calculateDomain([5, -3, 2], -10, undefined)).toEqual({ min: -10, max: 5 });
-      expect(calculateDomain([5, -3, 2], undefined, 10)).toEqual({ min: -3, max: 10 });
+      expect(calculateDomain([-100, 50, 200], { explicitMin: -10, explicitMax: 10 })).toEqual({ min: -10, max: 10 });
+      expect(calculateDomain([5, -3, 2], { explicitMin: -10 })).toEqual({ min: -10, max: 5 });
+      expect(calculateDomain([5, -3, 2], { explicitMax: 10 })).toEqual({ min: -3, max: 10 });
     });
   });
 
   describe('plot and symbol helpers', () => {
     it('maps values to plot points and handles zero-range values', () => {
-      const points = toPlotPoints([5, 5], 5, 5, 120);
+      const points = toPlotPoints([5, 5], { min: 5, max: 5 }, { width: 120 });
       expect(points).toEqual([
         { x: 0, y: 50 },
         { x: 120, y: 50 }
       ]);
-      expect(valueToY(5, 5, 5)).toBe(50);
+      expect(valueToY(5, { min: 5, max: 5 })).toBe(50);
     });
 
     it('resolves symbol indices for all boolean flag permutations', () => {
@@ -93,14 +93,14 @@ describe('sparkline.utils', () => {
       ] as const;
 
       for (const { flags, expected } of cases) {
-        const [denoteFirst, denoteLast, denoteMin, denoteMax] = flags;
-        const actual = Array.from(calculateSymbolIndices(values, denoteFirst, denoteLast, denoteMin, denoteMax));
+        const [first, last, min, max] = flags;
+        const actual = Array.from(calculateSymbolIndices(values, { first, last, min, max }));
         expect(actual).toEqual(expected);
       }
     });
 
     it('returns no symbol indices for empty values', () => {
-      expect(Array.from(calculateSymbolIndices([], true, true, true, true))).toEqual([]);
+      expect(Array.from(calculateSymbolIndices([], { first: true, last: true, min: true, max: true }))).toEqual([]);
     });
   });
 
@@ -183,7 +183,7 @@ describe('sparkline.utils', () => {
 
   describe('winloss rect builders', () => {
     it('builds winloss rects with expected class and geometry', () => {
-      const winlossRects = toWinLossRects([1, 0, -1], 50, 180, 100);
+      const winlossRects = toWinLossRects([1, 0, -1], 50, { width: 180, height: 100 });
       expect(winlossRects).toEqual([
         { className: 'win', x: 4.5, y: 0, width: 51, height: 50 },
         { className: 'draw', x: 64.5, y: 37.5, width: 51, height: 25 },
@@ -192,12 +192,12 @@ describe('sparkline.utils', () => {
     });
 
     it('centers a single winloss bar with the expected width', () => {
-      const [winlossRect] = toWinLossRects([1], 50, 60, 100);
+      const [winlossRect] = toWinLossRects([1], 50, { width: 60, height: 100 });
       expect(winlossRect).toEqual({ className: 'win', x: 4.5, y: 0, width: 51, height: 50 });
     });
 
     it('returns no rects for empty winloss inputs', () => {
-      expect(toWinLossRects([], 50, 120, 100)).toEqual([]);
+      expect(toWinLossRects([], 50, { width: 120, height: 100 })).toEqual([]);
     });
   });
 });

projects/core/src/sparkline/sparkline.utils.ts

@@ -36,11 +36,10 @@ export function calculateViewBox(
 
 export function calculateDomain(
   values: number[],
-  explicitMin?: number,
-  explicitMax?: number,
-  includeZero = false
+  options: { explicitMin?: number; explicitMax?: number; includeZero?: boolean } = {}
 ): Scale | undefined {
   if (values.length === 0) return undefined;
+  const { explicitMin, explicitMax, includeZero = false } = options;
 
   const dataMinimum = Math.min(...values);
   const dataMaximum = Math.max(...values);
@@ -51,48 +50,44 @@ export function calculateDomain(
   };
 }
 
-export function valueToY(value: number, min: number, max: number, viewHeight = VIEW_HEIGHT): number {
-  const range = max - min;
-  if (range === 0) return viewHeight / 2;
-  return viewHeight - ((value - min) / range) * viewHeight;
+export function valueToY(value: number, range: { min: number; max: number }, viewHeight = VIEW_HEIGHT): number {
+  const span = range.max - range.min;
+  if (span === 0) return viewHeight / 2;
+  return viewHeight - ((value - range.min) / span) * viewHeight;
 }
 
 export function toPlotPoints(
   values: number[],
-  min: number,
-  max: number,
-  viewWidth: number,
-  viewHeight = VIEW_HEIGHT
+  range: { min: number; max: number },
+  view: { width: number; height?: number }
 ): Point[] {
-  const stepX = values.length > 1 ? viewWidth / (values.length - 1) : 0;
+  const viewHeight = view.height ?? VIEW_HEIGHT;
+  const stepX = values.length > 1 ? view.width / (values.length - 1) : 0;
   return values.map((value, index) => ({
     x: index * stepX,
-    y: valueToY(value, min, max, viewHeight)
+    y: valueToY(value, range, viewHeight)
   }));
 }
 
 export function calculateSymbolIndices(
   values: number[],
-  denoteFirst: boolean,
-  denoteLast: boolean,
-  denoteMin: boolean,
-  denoteMax: boolean
+  denote: { first: boolean; last: boolean; min: boolean; max: boolean }
 ): Set<number> {
   const indices = new Set<number>();
   if (values.length === 0) return indices;
 
-  if (denoteFirst) indices.add(0);
-  if (denoteLast) indices.add(values.length - 1);
+  if (denote.first) indices.add(0);
+  if (denote.last) indices.add(values.length - 1);
 
-  const needsExtrema = denoteMin || denoteMax;
+  const needsExtrema = denote.min || denote.max;
   if (!needsExtrema) return indices;
 
   const min = Math.min(...values);
   const max = Math.max(...values);
 
   values.forEach((value, index) => {
-    if (denoteMin && value === min) indices.add(index);
-    if (denoteMax && value === max) indices.add(index);
+    if (denote.min && value === min) indices.add(index);
+    if (denote.max && value === max) indices.add(index);
   });
 
   return indices;
@@ -174,11 +169,14 @@ export function toColumnRects(points: Point[], baselineY: number, width: number)
 export function toWinLossRects(
   values: number[],
   baselineY: number,
-  width: number,
-  height: number
+  dimensions: { width: number; height: number }
 ): (Rect & { className: 'win' | 'loss' | 'draw' })[] {
-  const { bandSize: bandWidth, stepSize: stepX } = calculateBandSizing(values.length, width, WINLOSS_GAP_RATIO);
-  const barHeight = height / 2;
+  const { bandSize: bandWidth, stepSize: stepX } = calculateBandSizing(
+    values.length,
+    dimensions.width,
+    WINLOSS_GAP_RATIO
+  );
+  const barHeight = dimensions.height / 2;
 
   return values.map((value, index) => {
     const x = index * stepX + (stepX - bandWidth) / 2;

projects/core/src/tabs/tabs-group.ts

@@ -164,7 +164,7 @@ export class TabsGroup extends LitElement {
       return;
     }
 
-    this.#setActiveTab(tabItems, tabItem, true);
+    this.#setActiveTab(tabItems, tabItem, { emitEvent: true });
   };
 
   // --- Tab strip sync (tabs → state) ---
@@ -198,7 +198,7 @@ export class TabsGroup extends LitElement {
       return;
     }
 
-    this.#setActiveTab(tabItems, selectedTab, false, nextPanelValues);
+    this.#setActiveTab(tabItems, selectedTab, { emitEvent: false, nextPanelValues });
   }
 
   /**
@@ -209,9 +209,10 @@ export class TabsGroup extends LitElement {
   #setActiveTab(
     tabItems: TabsItem[],
     nextTab: TabsItem,
-    emitEvent: boolean,
-    nextPanelValues: string[] = uniqueNonEmptyStrings(tabItems.map(item => item.value))
+    options: { emitEvent: boolean; nextPanelValues?: string[] }
   ): void {
+    const { emitEvent } = options;
+    const nextPanelValues = options.nextPanelValues ?? uniqueNonEmptyStrings(tabItems.map(item => item.value));
     // True when the effective selection differs from the prior committed state (value, flags, or multi-select).
     // `select` is only dispatched when both `emitEvent` (invoker/command path) and `changed` are true.
     const changed =

projects/forms/src/internal/schema.ts

@@ -4,7 +4,6 @@
 import type { Schema } from './types.js';
 import { FormControlError } from './errors.js';
 
-// eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters -- caller specifies T for typed return
 export function parseValueSchema<T>(formControlName: string, value: string, schema: Schema): T {
   const parsedValue = parseControlValue(value, schema);
   if (parsedValue === undefined) {
@@ -89,15 +88,15 @@ function validateArray(schema: Schema & { type: 'array' }, value: unknown): Vali
 }
 
 function validateObjectProperty(
-  prop: string,
-  propSchema: Schema,
+  property: { name: string; schema: Schema },
   value: Record<string, unknown>,
   required?: string[]
 ): ValidationResult {
-  const propValue = value[prop];
+  const { name, schema: propSchema } = property;
+  const propValue = value[name];
   if (propValue === undefined) {
-    if (required?.includes(prop)) {
-      return invalid({ valueMissing: true }, `missing required property: ${prop}`);
+    if (required?.includes(name)) {
+      return invalid({ valueMissing: true }, `missing required property: ${name}`);
     }
     return VALID;
   }
@@ -118,7 +117,11 @@ function validateObject(schema: Schema & { type: 'object' }, value: unknown): Va
   }
 
   for (const [prop, propSchema] of Object.entries(schema.properties)) {
-    const result = validateObjectProperty(prop, propSchema, value as Record<string, unknown>, schema.required);
+    const result = validateObjectProperty(
+      { name: prop, schema: propSchema },
+      value as Record<string, unknown>,
+      schema.required
+    );
     if (!result.validity.valid) {
       return result;
     }
@@ -160,7 +163,6 @@ export function validateSchema(schema: Schema, value: unknown): ValidationResult
   }
 }
 
-// eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters -- caller specifies T for typed return
 export function parseControlValue<T>(value: string, schema: Schema): T | undefined {
   const schemaType = schema.type;
   let parsedValue: unknown;

projects/internals/eslint/src/configs/typescript.js

@@ -82,6 +82,7 @@ const config = {
     'no-warning-comments': 'error',
     'no-shadow': ['error', { allow: ['_', 'args', 'resolve', 'cwd'] }], // globals and a few large refactors
     'no-restricted-imports': ['error', { patterns: ['**/dist/**', '**/node_modules/**'] }],
+    'max-params': ['error', 3],
     'max-lines': ['error', 1000],
     'max-lines-per-function': ['error', 50],
     'max-statements-per-line': ['error', { max: 1 }],
@@ -134,7 +135,6 @@ const config = {
     '@typescript-eslint/prefer-readonly': 'off',
     '@typescript-eslint/explicit-function-return-type': 'off',
     'id-length': ['off', { min: 2, exceptions: ['_'] }],
-    'max-params': ['error', 6], // goal 3
     'max-statements': ['error', 20], // goal 15
     'max-depth': ['off', 3],
     'max-nested-callbacks': ['off', 3]