@ovh-ux/manager-static-analysis-kit 0.7.1 → 0.8.0

package/CHANGELOG.md

@@ -3,6 +3,32 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# [0.8.0](https://github.com/ovh/manager/compare/@ovh-ux/manager-static-analysis-kit@0.7.1...@ovh-ux/manager-static-analysis-kit@0.8.0) (2025-09-11)
+
+
+### Bug Fixes
+
+* adjust folder naming conventions rules ([fc7f608](https://github.com/ovh/manager/commit/fc7f6083038831902657e58f24792c7847f42d9c)), closes [#MANAGER-19352](https://github.com/ovh/manager/issues/MANAGER-19352)
+* adjust thresholds ([bd950f1](https://github.com/ovh/manager/commit/bd950f1fb8e972475e9c0a26915470f4f2e29fd4)), closes [#MANAGER-19352](https://github.com/ovh/manager/issues/MANAGER-19352)
+* ci lint issues ([c7b389e](https://github.com/ovh/manager/commit/c7b389e552cc1478998ad6dd24eb5c59328751da)), closes [#MANAGER-19352](https://github.com/ovh/manager/issues/MANAGER-19352)
+* indentation issues ([f106dcf](https://github.com/ovh/manager/commit/f106dcf283eb453d97a5f575327f4bd7e8eb9ccb)), closes [#MANAGER-19352](https://github.com/ovh/manager/issues/MANAGER-19352)
+* perf budgets readme doc indentation ([00660ba](https://github.com/ovh/manager/commit/00660ba9c418757dfc25dbb92be2af0a6e3dfea6)), closes [#MANAGER-19352](https://github.com/ovh/manager/issues/MANAGER-19352)
+* readme doc indentation ([e54e5eb](https://github.com/ovh/manager/commit/e54e5eb4c0bda11f7dc1c9e41bde804664420939)), closes [#MANAGER-19352](https://github.com/ovh/manager/issues/MANAGER-19352)
+* static kit integration status ([9a49e4f](https://github.com/ovh/manager/commit/9a49e4f992311de0ec2ac2876720dc46202ed118)), closes [#MANAGER-19352](https://github.com/ovh/manager/issues/MANAGER-19352)
+
+
+### Features
+
+* add new cli commands ([cfe81c2](https://github.com/ovh/manager/commit/cfe81c255885165fdfd12bb9ba6e0a81fc8f4d18)), closes [#MANAGER-19352](https://github.com/ovh/manager/issues/MANAGER-19352)
+* add safety check and testing scenarios cases ([04d9b74](https://github.com/ovh/manager/commit/04d9b747f84e7475eee267f5311bebcdb1a6749a)), closes [#MANAGER-19352](https://github.com/ovh/manager/issues/MANAGER-19352)
+* include shared in turbo build by default ([d006428](https://github.com/ovh/manager/commit/d0064281ef1a4c844fa574169fac17d2301e976b)), closes [#MANAGER-19352](https://github.com/ovh/manager/issues/MANAGER-19352)
+* integrate and configure bundle analysis ([514d424](https://github.com/ovh/manager/commit/514d4247b6b6e4b37379e64e5260636b5d1c7c4d)), closes [#MANAGER-19352](https://github.com/ovh/manager/issues/MANAGER-19352)
+* remove debug features ([7d1ac89](https://github.com/ovh/manager/commit/7d1ac892639831ace9a539d156775dbeeae19579)), closes [#MANAGER-19352](https://github.com/ovh/manager/issues/MANAGER-19352)
+
+
+
+
+
 ## [0.7.1](https://github.com/ovh/manager/compare/@ovh-ux/manager-static-analysis-kit@0.7.0...@ovh-ux/manager-static-analysis-kit@0.7.1) (2025-08-14)
 
 

package/bin/cli-utils.js

@@ -0,0 +1,56 @@
+import fs from 'node:fs';
+
+/**
+ * Log an informational message with a standard prefix.
+ *
+ * @param {string} msg - The message to log.
+ * @returns {void}
+ */
+export function logInfo(msg) {
+  console.log(`[manager-perf-budget] ${msg}`);
+}
+
+/**
+ * Log a warning message with a standard prefix.
+ *
+ * @param {string} msg - The message to log.
+ * @returns {void}
+ */
+export function logWarn(msg) {
+  console.warn(`⚠️  [manager-perf-budget] ${msg}`);
+}
+
+/**
+ * Log an error message with a standard prefix.
+ *
+ * @param {string} msg - The message to log.
+ * @returns {void}
+ */
+export function logError(msg) {
+  console.error(`❌ [manager-perf-budget] ${msg}`);
+}
+
+/**
+ * Check if a given package.json belongs to a React app.
+ *
+ * A package is considered a React app if it declares `react`
+ * as a dependency, devDependency, or peerDependency.
+ *
+ * @param {string} pkgPath - Absolute path to a `package.json` file.
+ * @returns {boolean} True if the package depends on React, otherwise false.
+ */
+export function isReactApp(pkgPath) {
+  try {
+    if (!fs.existsSync(pkgPath)) return false;
+
+    /** @type {Record<string, any>} */
+    const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+    if (!pkg || typeof pkg !== 'object') return false;
+
+    const deps = { ...pkg.dependencies, ...pkg.devDependencies, ...pkg.peerDependencies };
+    return Boolean(deps.react);
+  } catch (err) {
+    logWarn(`Failed to read or parse ${pkgPath}: ${err.message}`);
+    return false;
+  }
+}

package/bin/lint-cli.js

@@ -1,11 +1,12 @@
 #!/usr/bin/env node
-import { spawn } from 'child_process';
-import { fileURLToPath, pathToFileURL } from 'url';
-import { dirname, resolve, join } from 'path';
-import { cwd } from 'process';
-import { existsSync } from 'fs';
+import { spawn } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import process, { cwd } from 'node:process';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+
+import { logError, logInfo } from './cli-utils.js';
 
-// eslint-disable-next-line no-underscore-dangle
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const userCwd = cwd();
 const eslintBin = resolve(__dirname, '../node_modules/.bin/eslint');
@@ -13,11 +14,13 @@ const eslintBin = resolve(__dirname, '../node_modules/.bin/eslint');
 const args = process.argv.slice(2);
 const hasExplicitConfigArg = args.includes('--config');
 const localConfigPath = join(userCwd, 'eslint.config.ts');
-const sharedDefaultPath = resolve(__dirname, '../dist/adapters/eslint/config/eslint-shared-config.js');
+const sharedDefaultPath = resolve(
+  __dirname,
+  '../dist/adapters/eslint/config/eslint-shared-config.js',
+);
 const hasLocalConfig = existsSync(localConfigPath);
 
 // Determine effective config path
-// eslint-disable-next-line no-nested-ternary
 const configPath = hasExplicitConfigArg
   ? args[args.indexOf('--config') + 1]
   : hasLocalConfig
@@ -34,8 +37,8 @@ function runLint(command, args, cwd) {
     });
 
     child.on('error', (err) => {
-      console.error('[manager-lint] Failed to run ESLint');
-      console.error(err);
+      logError('[manager-lint] Failed to run ESLint');
+      logError(err);
       reject(1);
     });
 
@@ -52,20 +55,19 @@ function runLint(command, args, cwd) {
     try {
       const mod = await import(url);
       const configContent = mod.default ?? mod;
-      console.log('[manager-lint] Loaded ESLint config from:', configPath);
+      logInfo('[manager-lint] Loaded ESLint config from:', configPath);
       console.dir(configContent, { depth: null });
     } catch (err) {
-      console.error(`[manager-lint] Failed to load config at ${configPath}`);
-      console.error(err);
+      logError(`[manager-lint] Failed to load config at ${configPath}`);
+      logError(err);
       process.exit(1);
     }
     process.exit(0);
   }
 
   // Construct full args
-  const fullArgs = hasExplicitConfigArg || hasLocalConfig
-    ? args
-    : ['--config', sharedDefaultPath, ...args];
+  const fullArgs =
+    hasExplicitConfigArg || hasLocalConfig ? args : ['--config', sharedDefaultPath, ...args];
 
   // Run ESLint using tsx and wait for completion
   const exitCode = await runLint('tsx', [eslintBin, ...fullArgs], userCwd);

package/bin/perf-budgets-cli.js

@@ -0,0 +1,359 @@
+#!/usr/bin/env node
+import { spawnSync } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+import process from 'node:process';
+import { fileURLToPath } from 'node:url';
+
+import {
+  collectPerfBudgets,
+  generatePerfBudgetsHtml,
+} from '../dist/adapters/perf-budgets/helpers/perfs-bundle-analysis-helper.js';
+import { bundleAnalysisConfig } from '../dist/configs/bundle-analysis-config.js';
+import { isReactApp, logError, logInfo, logWarn } from './cli-utils.js';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const rootDir = path.resolve(__dirname, '../../..');
+const outputRootDir = path.resolve(__dirname, '../../../..');
+const appsDir = path.join(rootDir, 'manager/apps');
+const bundleAnalyzerBin = path.resolve(__dirname, '../node_modules/.bin/analyze');
+const perfBudgetsReportDirName = 'perf-budgets-reports';
+const perfBudgetCombinedJsonReportName = 'perf-budgets-combined-report.json';
+const perfBudgetCombinedHtmlReportName = 'perf-budgets-combined-report.html';
+
+// Shared packages that must always be built
+const sharedPackages = [
+  {
+    name: '@ovh-ux/manager-react-components',
+    folder: 'manager-react-components',
+    path: path.join(rootDir, 'packages/manager-react-components'),
+  },
+];
+
+/**
+ * Run vite-bundle-analyzer for given mode (html or json).
+ */
+function runBundleAnalyzer(appDirectory, appShortName, mode) {
+  const reportFile = `${bundleAnalysisConfig?.reportFile || 'bundle-report'}${
+    mode === 'json' ? '.json' : '.html'
+  }`;
+  const outputDir = path.join(outputRootDir, perfBudgetsReportDirName, appShortName);
+  fs.mkdirSync(outputDir, { recursive: true });
+
+  logInfo(`Running bundle analyzer (${mode}) for ${appShortName} → ${outputDir}`);
+
+  const analyzerArgs = [
+    '--mode',
+    mode,
+    '--no-open',
+    '--filename',
+    bundleAnalysisConfig?.reportFile || 'bundle-report',
+  ];
+
+  const result = spawnSync(bundleAnalyzerBin, analyzerArgs, {
+    cwd: appDirectory,
+    stdio: 'inherit',
+    shell: true,
+  });
+
+  if (result.status !== 0) {
+    logError(`❌ Analyzer (${mode}) failed for ${appShortName}`);
+    return;
+  }
+
+  const distReport = path.join(appDirectory, 'dist', reportFile);
+  const targetReport = path.join(outputDir, reportFile);
+
+  if (fs.existsSync(distReport)) {
+    fs.copyFileSync(distReport, targetReport);
+    logInfo(`✅ ${mode.toUpperCase()} report copied to ${targetReport}`);
+    return targetReport;
+  } else {
+    logWarn(`⚠️ Expected ${mode} report not found at ${distReport}`);
+  }
+}
+
+/**
+ * Build selected targets with Turbo.
+ */
+function runTurboBuild(filters) {
+  if (filters.length === 0) {
+    logWarn('⚠️ No Turbo build filters provided, skipping build step.');
+    return;
+  }
+
+  const turboArgs = ['run', 'build', ...filters.flatMap((pkgName) => ['--filter', pkgName])];
+  logInfo(`Building with Turbo (filters: ${filters.join(', ')})`);
+
+  const buildResult = spawnSync('turbo', turboArgs, {
+    cwd: rootDir,
+    stdio: 'inherit',
+    shell: true,
+  });
+
+  if (buildResult.status !== 0) {
+    logWarn('⚠️ Turbo build failed for one or more targets. Will still try to analyze apps.');
+  }
+}
+
+/**
+ * Analyze all given app folders.
+ */
+function analyzeAppFolders(appFolders) {
+  const analyzed = [];
+  for (const appFolder of appFolders) {
+    try {
+      const appDir = path.join(appsDir, appFolder);
+      if (!fs.existsSync(appDir)) {
+        logError(`❌ App folder not found: ${appFolder} → skipping`);
+        continue;
+      }
+
+      const pkg = JSON.parse(fs.readFileSync(path.join(appDir, 'package.json'), 'utf-8'));
+      const appName = pkg.name;
+      const appShortName = appName.replace(/^@ovh-ux\//, '');
+
+      runBundleAnalyzer(appDir, appShortName, 'static');
+      runBundleAnalyzer(appDir, appShortName, 'json');
+
+      analyzed.push(appName);
+    } catch (err) {
+      logError(`❌ Failed to analyze ${appFolder}: ${err.message}`);
+    }
+  }
+  return analyzed;
+}
+
+/**
+ * Remove old combined perf budget reports.
+ */
+function removeOldCombinedReports() {
+  const combinedJsonPath = path.join(
+    outputRootDir,
+    perfBudgetsReportDirName,
+    perfBudgetCombinedJsonReportName,
+  );
+  const combinedHtmlPath = path.join(
+    outputRootDir,
+    perfBudgetsReportDirName,
+    perfBudgetCombinedHtmlReportName,
+  );
+
+  [combinedJsonPath, combinedHtmlPath].forEach((file) => {
+    if (fs.existsSync(file)) {
+      fs.unlinkSync(file);
+      logInfo(`🗑️ Removed old report: ${file}`);
+    }
+  });
+}
+
+/**
+ * Collect budgets and regenerate combined reports.
+ */
+function generateCombinedReports(root) {
+  removeOldCombinedReports();
+
+  const summary = collectPerfBudgets(root);
+
+  const combinedJsonPath = path.join(
+    root,
+    perfBudgetsReportDirName,
+    perfBudgetCombinedJsonReportName,
+  );
+  fs.writeFileSync(combinedJsonPath, JSON.stringify(summary, null, 2));
+  logInfo(`✅ Combined JSON report written to ${combinedJsonPath}`);
+
+  const combinedHtmlPath = path.join(
+    root,
+    perfBudgetsReportDirName,
+    perfBudgetCombinedHtmlReportName,
+  );
+  fs.writeFileSync(combinedHtmlPath, generatePerfBudgetsHtml(summary));
+  logInfo(`✅ Combined HTML report written to ${combinedHtmlPath}`);
+}
+
+/**
+ * Guess app folder name from package name.
+ * Example: @ovh-ux/manager-zimbra-app -> zimbra
+ */
+function extractAppFolderFromPackageName(packageName) {
+  const match = packageName.match(/^@ovh-ux\/manager-(.+)-app$/);
+  if (!match) {
+    logError(`❌ Invalid package name format: ${packageName}`);
+    return null;
+  }
+  return match[1];
+}
+
+/**
+ * Convert app folders to Turbo filters (package names).
+ */
+function resolveTurboFiltersFromAppFolders(appFolders) {
+  return appFolders
+    .map((appFolder) => {
+      const pkgPath = path.join(appsDir, appFolder, 'package.json');
+      if (!fs.existsSync(pkgPath)) {
+        logError(`❌ No package.json for app folder ${appFolder}, skipping`);
+        return null;
+      }
+      const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+      return pkg.name;
+    })
+    .filter(Boolean);
+}
+
+/**
+ * Parse CLI arguments for `--apps` or `--app` flags.
+ *
+ * @returns {{appFolders: string[], packageNames: string[]} | null}
+ *   An object with valid app folder names and an empty packageNames array,
+ *   or null if the flag is not present.
+ */
+function parseAppsArg() {
+  const appsArg = process.argv.find((arg) => arg === '--apps' || arg === '--app');
+  if (!appsArg) return null;
+
+  const index = process.argv.indexOf(appsArg);
+  const rawValue = process.argv[index + 1] || '';
+  const appFolders = rawValue
+    .split(',')
+    .map((n) => n.trim())
+    .filter(Boolean);
+
+  const validFolders = appFolders.filter((folder) => {
+    if (!fs.existsSync(path.join(appsDir, folder))) {
+      logError(`❌ App not found: ${folder} → skipping`);
+      return false;
+    }
+    return true;
+  });
+
+  logInfo(`Running in apps mode for: ${validFolders.join(', ')}`);
+  return { appFolders: validFolders, packageNames: [] };
+}
+
+/**
+ * Parse CLI arguments for `--packages` or `--package` flags.
+ *
+ * @returns {{appFolders: string[], packageNames: string[]} | null}
+ *   An object mapping package names to their corresponding app folders,
+ *   or null if the flag is not present.
+ */
+function parsePackagesArg() {
+  const packagesArg = process.argv.find((arg) => arg === '--packages' || arg === '--package');
+  if (!packagesArg) return null;
+
+  const index = process.argv.indexOf(packagesArg);
+  const rawValue = process.argv[index + 1] || '';
+  const packageNames = rawValue
+    .split(',')
+    .map((n) => n.trim())
+    .filter(Boolean);
+
+  const mappedFolders = [];
+  for (const pkgName of packageNames) {
+    const folder = extractAppFolderFromPackageName(pkgName);
+    if (folder && fs.existsSync(path.join(appsDir, folder))) {
+      mappedFolders.push(folder);
+    } else {
+      logError(`❌ Package ${pkgName} → app folder ${folder} not found, skipping`);
+    }
+  }
+
+  logInfo(
+    `Running in packages mode for: ${packageNames.join(', ')} → apps: ${mappedFolders.join(', ')}`,
+  );
+  return { appFolders: mappedFolders, packageNames };
+}
+
+/**
+ * Discover all React apps automatically when no CLI flags are provided.
+ *
+ * @returns {{appFolders: string[], packageNames: string[]}}
+ *   An object containing discovered React app folders and an empty packageNames array.
+ */
+function discoverApps() {
+  const discoveredAppFolders = fs.readdirSync(appsDir).filter((dir) => {
+    const pkgPath = path.join(appsDir, dir, 'package.json');
+    return fs.existsSync(pkgPath) && isReactApp(pkgPath);
+  });
+
+  if (discoveredAppFolders.length === 0) {
+    logWarn('⚠️ No React apps found to analyze.');
+    return { appFolders: [], packageNames: [] };
+  }
+
+  logInfo(`Running in auto-discovery mode (${discoveredAppFolders.length} apps).`);
+  return { appFolders: discoveredAppFolders, packageNames: [] };
+}
+
+/**
+ * Parse CLI arguments to resolve which apps or packages should be analyzed.
+ *
+ * Priority:
+ *  1. Explicit `--apps`
+ *  2. Explicit `--packages`
+ *  3. Auto-discovery fallback
+ *
+ * @returns {{appFolders: string[], packageNames: string[]}}
+ *   Object containing app folder names and package names for analysis.
+ */
+function parseCliTargets() {
+  return parseAppsArg() || parsePackagesArg() || discoverApps();
+}
+
+/**
+ * Resolve Turbo filters (package names) depending on mode.
+ */
+function resolveTurboFilters({ appFolders, packageNames }) {
+  let filters = [];
+  if (appFolders.length > 0 && packageNames.length === 0) {
+    filters = resolveTurboFiltersFromAppFolders(appFolders);
+  } else if (packageNames.length > 0) {
+    filters = packageNames;
+  }
+
+  // Always include shared packages for build
+  for (const pkg of sharedPackages) {
+    if (fs.existsSync(pkg.path) && !filters.includes(pkg.name)) {
+      filters.push(pkg.name);
+      logInfo(`Including shared dependency in build: ${pkg.name}`);
+    }
+  }
+
+  return filters;
+}
+
+/**
+ * Main CLI entrypoint.
+ */
+function main() {
+  try {
+    if (!fs.existsSync(bundleAnalyzerBin)) {
+      logError(`❌ Analyzer binary not found at ${bundleAnalyzerBin}`);
+      return;
+    }
+
+    const { appFolders, packageNames } = parseCliTargets();
+    const turboFilters = resolveTurboFilters({ appFolders, packageNames });
+
+    // Step 1: build
+    runTurboBuild(turboFilters);
+
+    // Step 2: analyze
+    const analyzedApps = analyzeAppFolders(appFolders);
+
+    // Step 3: combined reports
+    if (analyzedApps.length > 0) {
+      generateCombinedReports(outputRootDir);
+    } else {
+      logError('❌ No apps successfully analyzed. Exiting.');
+      process.exit(1);
+    }
+  } catch (err) {
+    logError(`Fatal error: ${err.stack || err.message}`);
+    process.exit(1);
+  }
+}
+
+main();

package/bin/perf-budgets-tests-cli.js

@@ -0,0 +1,74 @@
+#!/usr/bin/env node
+import { spawnSync } from 'node:child_process';
+import process from 'node:process';
+
+import { logError, logInfo } from './cli-utils.js';
+
+// Define the set of validation test cases
+const cases = [
+  // This case take too much time since it builds all apps, use it only for debug
+  // { name: 'Auto-discovery (all apps)', cmd: 'yarn manager-perf-budgets', expect: 0 },
+  { name: 'Single app (zimbra)', cmd: 'yarn manager-perf-budgets --app zimbra', expect: 0 },
+  {
+    name: 'Multiple apps (container,zimbra)',
+    cmd: 'yarn manager-perf-budgets --apps container,zimbra',
+    expect: 0,
+  },
+  {
+    name: 'Single package (container)',
+    cmd: 'yarn manager-perf-budgets --package @ovh-ux/manager-container-app',
+    expect: 0,
+  },
+  {
+    name: 'Multiple packages (zimbra,pci-workflow)',
+    cmd: 'yarn manager-perf-budgets --packages @ovh-ux/manager-zimbra-app,@ovh-ux/manager-pci-workflow-app',
+    expect: 0,
+  },
+  {
+    name: 'Mixed valid+invalid apps',
+    cmd: 'yarn manager-perf-budgets --apps zimbra,unknown-app,container',
+    expect: 0,
+  },
+  {
+    name: 'Mixed valid+invalid packages',
+    cmd: 'yarn manager-perf-budgets --packages @ovh-ux/manager-zimbra-app,@ovh-ux/manager-ghost-app',
+    expect: 0,
+  },
+  {
+    name: 'All invalid apps',
+    cmd: 'yarn manager-perf-budgets --apps doesnotexist1,doesnotexist2',
+    expect: 1,
+  },
+  {
+    name: 'All invalid packages',
+    cmd: 'yarn manager-perf-budgets --packages @ovh-ux/manager-ghost-app,@ovh-ux/manager-missing-app',
+    expect: 1,
+  },
+  {
+    name: 'Turbo build failure simulation (pci-ai-tools)',
+    cmd: 'yarn manager-perf-budgets --app pci-ai-tools',
+    expect: 0,
+  },
+];
+
+let failed = 0;
+
+for (const test of cases) {
+  logInfo(`\n🔎 Running: ${test.name}`);
+  const [bin, ...args] = test.cmd.split(' ');
+  const result = spawnSync(bin, args, { stdio: 'inherit', shell: true });
+
+  if (result.status !== test.expect) {
+    logError(`❌ ${test.name} failed (expected exit ${test.expect}, got ${result.status})`);
+    failed++;
+  } else {
+    logInfo(`✅ ${test.name} passed`);
+  }
+}
+
+if (failed > 0) {
+  logError(`\n❌ ${failed} test(s) failed.`);
+  process.exit(1);
+} else {
+  logInfo('\n🎉 All perf-budgets CLI validation tests passed!');
+}

package/dist/adapters/eslint/rules/eslint-naming-conventions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"eslint-naming-conventions.d.ts","sourceRoot":"","sources":["../../../../src/adapters/eslint/rules/eslint-naming-conventions.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAUhC,eAAO,MAAM,qBAAqB,EAAE,MAAM,CAAC,UAAU,EA0CpD,CAAC"}
+{"version":3,"file":"eslint-naming-conventions.d.ts","sourceRoot":"","sources":["../../../../src/adapters/eslint/rules/eslint-naming-conventions.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAUhC,eAAO,MAAM,qBAAqB,EAAE,MAAM,CAAC,UAAU,EA2CpD,CAAC"}

package/dist/adapters/eslint/rules/eslint-naming-conventions.js

@@ -28,6 +28,7 @@ export const checkFileEslintConfig = [
                 folderNamingConvention,
                 {
                     errorMessage: 'Folder "{{ target }}" must follow the "{{ pattern }}" naming convention. See µ-app guidelines.',
+                    ignoreWords: ['__tests__', '__mocks__'],
                 },
             ],
         },

package/dist/adapters/perf-budgets/helpers/perfs-bundle-analysis-helper.d.ts

@@ -0,0 +1,7 @@
+import { PerfBudgetsSummary } from '../types/PerfBudget.js';
+import { ParsedAsset, ParsedBundle } from '../types/PerfBudgetAssets.js';
+export declare function escapeHtml(str: string): string;
+export declare function parseAnalyzerJson(raw: ParsedAsset[]): ParsedBundle;
+export declare function collectPerfBudgets(rootDir: string): PerfBudgetsSummary;
+export declare function generatePerfBudgetsHtml(summary: PerfBudgetsSummary): string;
+//# sourceMappingURL=perfs-bundle-analysis-helper.d.ts.map

package/dist/adapters/perf-budgets/helpers/perfs-bundle-analysis-helper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"perfs-bundle-analysis-helper.d.ts","sourceRoot":"","sources":["../../../../src/adapters/perf-budgets/helpers/perfs-bundle-analysis-helper.ts"],"names":[],"mappings":"AAMA,OAAO,EAAoB,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AAC3E,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAOtE,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAO9C;AAmCD,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,WAAW,EAAE,GAAG,YAAY,CAgBlE;AASD,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,GAAG,kBAAkB,CAmCtE;AASD,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,kBAAkB,GAAG,MAAM,CAwJ3E"}