chore(ci): lint cleanup

- max-nested-callbacks
- max-statements
- max-depth

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

Author: coryrylan

patches/monaco-editor.patch

@@ -1166,4 +1166,4 @@ index 414405319ded9b3671a070b7405b7150afaa8321..c8b924d17e513acb02b8f8a74b75d8a7
 +                const element = this.domNode.getRootNode().querySelector(`#${this._list.getElementID(index)}`);
                  if (element) {
                      element.style.width = 'auto';
-                     const width = element.getBoundingClientRect().width;
+                     const width = element.getBoundingClientRect().width;

pnpm-lock.yaml

@@ -21,7 +21,7 @@ import globalStyles from './button-group.global.css?inline';
 
 /**
  * @element nve-button-group
- * @description A button group is a control that enables users to choose between two or more distinct mutually exclusive options.
+ * @description A button group organizes related buttons and can support either mutually exclusive single or multi selection. Prefer usage within toolbars.
  * @since 0.16.0
  * @entrypoint \@nvidia-elements/core/button-group
  * @slot - default slot for `nve-button` or `nve-icon-button`

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

@@ -8,6 +8,26 @@ import styles from './format-relative-time.css?inline';
 
 type TimeUnitOption = 'second' | 'minute' | 'hour' | 'day' | 'week' | 'month' | 'year';
 
+const UNIT_DIVISORS: Record<TimeUnitOption, number> = {
+  second: 1000,
+  minute: 60000,
+  hour: 3600000,
+  day: 86400000,
+  week: 604800000,
+  month: 2592000000,
+  year: 31536000000
+};
+
+const THRESHOLDS: { unit: TimeUnitOption; max: number }[] = [
+  { unit: 'second', max: 60 },
+  { unit: 'minute', max: 60 },
+  { unit: 'hour', max: 24 },
+  { unit: 'day', max: 7 },
+  { unit: 'week', max: 4 },
+  { unit: 'month', max: 12 },
+  { unit: 'year', max: Number.POSITIVE_INFINITY }
+];
+
 /**
  * @element nve-format-relative-time
  * @description Formats a date/time value as localized relative text using the Intl.RelativeTimeFormat API. Renders inside a semantic time element.
@@ -71,34 +91,22 @@ export class FormatRelativeTime extends LitElement {
     const absDiff = Math.abs(diffMs);
     const sign = diffMs < 0 ? -1 : 1;
 
-    const seconds = Math.round(absDiff / 1000);
-    const minutes = Math.round(absDiff / 60000);
-    const hours = Math.round(absDiff / 3600000);
-    const days = Math.round(absDiff / 86400000);
-    const weeks = Math.round(absDiff / 604800000);
-    const months = Math.round(absDiff / 2592000000);
-    const years = Math.round(absDiff / 31536000000);
-
-    if (seconds < 60) return { value: sign * seconds, unit: 'second' };
-    if (minutes < 60) return { value: sign * minutes, unit: 'minute' };
-    if (hours < 24) return { value: sign * hours, unit: 'hour' };
-    if (days < 7) return { value: sign * days, unit: 'day' };
-    if (weeks < 4) return { value: sign * weeks, unit: 'week' };
-    if (months < 12) return { value: sign * months, unit: 'month' };
-    return { value: sign * years, unit: 'year' };
+    for (const { unit, max } of THRESHOLDS) {
+      const value = Math.round(absDiff / UNIT_DIVISORS[unit]);
+      if (value < max) return { value: sign * value, unit };
+    }
+    throw new Error('format-relative-time: no relative time threshold matched');
   }
 
   #computeExplicitUnit(diffMs: number, unit: TimeUnitOption): number {
-    const divisors: Record<string, number> = {
-      second: 1000,
-      minute: 60000,
-      hour: 3600000,
-      day: 86400000,
-      week: 604800000,
-      month: 2592000000,
-      year: 31536000000
-    };
-    return Math.round(diffMs / (divisors[unit] ?? 1));
+    return Math.round(diffMs / UNIT_DIVISORS[unit]);
+  }
+
+  #resolveValueAndUnit(diffMs: number): { value: number; unit: Intl.RelativeTimeFormatUnit } {
+    if (this.unit === 'auto') {
+      return this.#computeUnit(diffMs);
+    }
+    return { unit: this.unit, value: this.#computeExplicitUnit(diffMs, this.unit) };
   }
 
   get #formattedRelativeTime(): string {
@@ -111,16 +119,7 @@ export class FormatRelativeTime extends LitElement {
       return iso;
     }
 
-    const diffMs = target.getTime() - Date.now();
-    let value: number;
-    let resolvedUnit: Intl.RelativeTimeFormatUnit;
-
-    if (this.unit === 'auto') {
-      ({ value, unit: resolvedUnit } = this.#computeUnit(diffMs));
-    } else {
-      resolvedUnit = this.unit;
-      value = this.#computeExplicitUnit(diffMs, resolvedUnit);
-    }
+    const { value, unit: resolvedUnit } = this.#resolveValueAndUnit(target.getTime() - Date.now());
 
     try {
       return new Intl.RelativeTimeFormat(this.#resolvedLocale, {

projects/core/src/format-relative-time/format-relative-time.ts

@@ -158,8 +158,6 @@ export const ResetForm = {
   }
 }
 
-/* eslint-disable @nvidia-elements/lint/no-missing-popover-trigger */
-
 @customElement('app-login')
 export class AppLogin extends LitElement {
   static styles = [unsafeCSS(layout)];

projects/core/src/forms/validation.examples.ts

@@ -25,21 +25,26 @@ export function deepMerge(
 
   if (isObjectLiteral(target) && isObjectLiteral(source)) {
     for (const key in source) {
-      if (isObjectLiteral(source[key])) {
-        if (isObjectLiteral(target[key])) {
-          deepMerge(target[key], source[key]);
-        } else {
-          target[key] = source[key];
-        }
-      } else {
-        Object.assign(target, { [key]: source[key] });
-      }
+      mergeProperty(target, source, key);
     }
   }
 
   return deepMerge(target, ...sources);
 }
 
+function mergeProperty(target: Record<string, unknown>, source: Record<string, unknown>, key: string) {
+  const sourceValue = source[key];
+  if (!isObjectLiteral(sourceValue)) {
+    target[key] = sourceValue;
+    return;
+  }
+  if (isObjectLiteral(target[key])) {
+    deepMerge(target[key], sourceValue);
+  } else {
+    target[key] = sourceValue;
+  }
+}
+
 export function parseVersion(version: string) {
   const [major, minor, patch] = version.split('.').map(v => {
     const n = parseInt(v, 10);

projects/core/src/internal/utils/objects.ts

@@ -17,6 +17,6 @@ describe('tooltip lighthouse report', () => {
     expect(report.scores.performance).toBe(100);
     expect(report.scores.accessibility).toBe(100);
     expect(report.scores.bestPractices).toBe(100);
-    expect(report.payload.javascript.kb).toBeLessThan(14.4);
+    expect(report.payload.javascript.kb).toBeLessThan(14.6);
   });
 });

projects/core/src/tooltip/tooltip.test.lighthouse.ts

@@ -165,37 +165,22 @@ export function validateSchema(schema: Schema, value: unknown): ValidationResult
 
 export function parseControlValue<T>(value: string, schema: Schema): T | undefined {
   const schemaType = schema.type;
-  let parsedValue: unknown;
 
   switch (schemaType) {
-    case 'string': {
-      parsedValue = value;
-      break;
-    }
-    case 'number': {
-      parsedValue = parseFloat(value);
-      break;
-    }
-    case 'boolean': {
-      parsedValue = !!value || value === 'true';
-      break;
-    }
-    case 'array': {
-      parsedValue = JSON.parse(value);
-      break;
-    }
-    case 'object': {
-      parsedValue = JSON.parse(value);
-      break;
-    }
-    case 'enum': {
-      parsedValue = schema.enum.includes(value) ? value : undefined;
-      break;
-    }
+    case 'string':
+      return value as T;
+    case 'number':
+      return parseFloat(value) as T;
+    case 'boolean':
+      return (!!value || value === 'true') as T;
+    case 'array':
+    case 'object':
+      return JSON.parse(value) as T;
+    case 'enum':
+      return (schema.enum.includes(value) ? value : undefined) as T;
     default: {
       const _exhaustiveCheck: never = schemaType;
       return undefined;
     }
   }
-  return parsedValue as T;
 }

projects/forms/src/internal/schema.ts

@@ -80,10 +80,13 @@ const config = {
     'no-useless-return': 'error',
     'no-param-reassign': 'error',
     'no-warning-comments': 'error',
+    'max-nested-callbacks': ['error', 3],
     'no-shadow': ['error', { allow: ['_', 'args', 'resolve', 'cwd'] }], // globals and a few large refactors
     'no-restricted-imports': ['error', { patterns: ['**/dist/**', '**/node_modules/**'] }],
+    'max-depth': ['error', 3],
     'max-params': ['error', 3],
     'max-lines': ['error', 1000],
+    'max-statements': ['error', 15],
     'max-lines-per-function': ['error', 50],
     'max-statements-per-line': ['error', { max: 1 }],
     'import/extensions': ['error', 'ignorePackages', { js: 'always', 'css?inline': 'never' }],
@@ -134,10 +137,7 @@ const config = {
     '@typescript-eslint/no-unnecessary-type-parameters': 'off',
     '@typescript-eslint/prefer-readonly': 'off',
     '@typescript-eslint/explicit-function-return-type': 'off',
-    'id-length': ['off', { min: 2, exceptions: ['_'] }],
-    'max-statements': ['error', 20], // goal 15
-    'max-depth': ['off', 3],
-    'max-nested-callbacks': ['off', 3]
+    'id-length': ['off', { min: 2, exceptions: ['_'] }]
   },
   settings: {
     jsdoc: {
@@ -190,6 +190,7 @@ export const browserTypescriptConfig = [
       'max-lines': 'off',
       'max-lines-per-function': 'off',
       'max-statements': 'off',
+      'max-nested-callbacks': 'off',
       'local-typescript/require-fixture-cleanup': ['error'],
       'local-typescript/require-element-stable': ['off'], // temporarily disabled, will enable in followup
       'local-typescript/require-listener-cleanup': ['off'],
@@ -238,6 +239,7 @@ export const nodeTypescriptConfig = [
       'max-lines': 'off',
       'max-statements': 'off',
       'max-lines-per-function': 'off',
+      'max-nested-callbacks': 'off',
       'local-typescript/require-fixture-cleanup': ['error'],
       'local-typescript/require-element-stable': ['off'], // temporarily disabled, will enable in followup
       'local-typescript/require-listener-cleanup': ['off'],

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

@@ -95,20 +95,23 @@ function extractWireitScripts(packageJsonPath: string) {
   }
 }
 
+function addDependency(dep: unknown, script: { packagePath: string; dependencies: string[] }, key: string) {
+  try {
+    const { packagePath, scriptName } = parseDependency(dep as string, script.packagePath);
+    if (packagePath) {
+      script.dependencies.push(`${packagePath}:${scriptName}`);
+    }
+  } catch (err) {
+    console.error(`error parsing dependency in ${key}:`, (err as Error).message);
+  }
+}
+
 function buildDependencyGraph() {
   for (const [key, script] of wireitScripts.entries()) {
     const deps = script.config.dependencies || [];
 
     for (const dep of deps) {
-      try {
-        const { packagePath, scriptName } = parseDependency(dep, script.packagePath);
-        if (packagePath) {
-          const depKey = `${packagePath}:${scriptName}`;
-          script.dependencies.push(depKey);
-        }
-      } catch (err) {
-        console.error(`error parsing dependency in ${key}:`, (err as Error).message);
-      }
+      addDependency(dep, script, key);
     }
   }
 }