@ovh-ux/manager-static-analysis-kit 0.10.0 → 0.11.1

package/bin/utils/args-parse-utils.js

@@ -1,143 +1,106 @@
-import fs from 'node:fs';
-import path from 'node:path';
 import process from 'node:process';
 
 import { codeDuplicationConfig } from '../../dist/configs/code-duplication-config.js';
 import { typesCoverageConfig } from '../../dist/configs/types-coverage-config.js';
-import { isReactApp } from './apps-utils.js';
-import { logError, logInfo, logWarn } from './log-utils.js';
+import { logError, logInfo } from './log-utils.js';
+import { discoverModules, getModule } from './module-utils.js';
 
 /**
- * Extract an app folder name from an OVH Manager package name.
+ * Parse CLI arguments to resolve target modules (apps, packages, or libraries).
  *
- * Example:
- *   "@ovh-ux/manager-zimbra-app" → "zimbra"
+ * This function looks for one of the supported flags in `process.argv`:
+ * - `--apps` or `--app`
+ * - `--packages` or `--package`
+ * - `--libraries` or `--library`
  *
- * @param {string} packageName - Full npm package name.
- * @returns {string|null} The extracted app folder name, or null if the format is invalid.
- */
-function extractAppFolderFromPackageName(packageName) {
-  const match = packageName.match(/^@ovh-ux\/manager-(.+)-app$/);
-  if (!match) {
-    logError(`❌ Invalid package name format: ${packageName}`);
-    return null;
-  }
-  return match[1];
-}
-
-/**
- * Parse CLI arguments for `--apps` or `--app` flags.
+ * Each flag must be followed by a comma-separated list of module identifiers.
+ * Each identifier is resolved using {@link getModule}, which returns a module descriptor.
  *
- * Accepts a comma-separated list of app folder names. Example:
- *   `--apps zimbra,web`
+ * For every valid pattern:
+ * - The corresponding module descriptor (containing `fullPath`, `shortPath`, and `packageName`)
+ *   is added to the result list.
+ * - If a module cannot be resolved, an error is logged and it is skipped.
  *
- * @param {string} appsDir - Absolute path to the apps root directory.
- * @returns {{appFolders: string[], packageNames: string[]} | null}
- *   Object containing valid app folders and an empty `packageNames` array,
- *   or null if no `--apps`/`--app` flag is provided.
- */
-function parseAppsArg(appsDir) {
-  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.
+ * @typedef {Object} ModuleDescriptor
+ * @property {string} fullPath - Absolute path to the module directory.
+ * @property {string} shortPath - Folder name (short identifier) of the module.
+ * @property {string} packageName - Full npm package name (e.g. "@ovh-ux/manager-core-shell").
  *
- * Accepts a comma-separated list of package names. Example:
- *   `--packages @ovh-ux/manager-zimbra-app,@ovh-ux/manager-web-app`
+ * @returns {ModuleDescriptor[] | null}
+ * Array of resolved module descriptors, or `null` if no supported CLI flags were provided.
  *
- * Each package name is mapped to its corresponding app folder.
+ * @example
+ * // Example 1: Apps mode
+ * // CLI: --apps zimbra,web
+ * parseArgs();
+ * // → [
+ * //   { fullPath: "/.../manager/apps/zimbra", shortPath: "zimbra", packageName: "@ovh-ux/manager-zimbra-app" },
+ * //   { fullPath: "/.../manager/apps/web", shortPath: "web", packageName: "@ovh-ux/manager-web-app" }
+ * // ]
  *
- * @param {string} appsDir - Absolute path to the apps root directory.
- * @returns {{appFolders: string[], packageNames: string[]} | null}
- *   Object mapping package names to discovered app folders,
- *   or null if no `--packages`/`--package` flag is provided.
+ * @example
+ * // Example 2: Libraries mode
+ * // CLI: --libraries core-shell,react-components
+ * parseArgs();
+ * // → [
+ * //   { fullPath: "/.../packages/manager/core/core-shell", shortPath: "core-shell", packageName: "@ovh-ux/manager-core-shell" },
+ * //   { fullPath: "/.../packages/components/react-components", shortPath: "react-components", packageName: "@ovh-ux/manager-react-components" }
+ * // ]
  */
-function parsePackagesArg(appsDir) {
+export function parseArgs() {
+  const libsArg = process.argv.find((arg) => arg === '--libraries' || arg === '--library');
   const packagesArg = process.argv.find((arg) => arg === '--packages' || arg === '--package');
-  if (!packagesArg) return null;
+  const appsArg = process.argv.find((arg) => arg === '--apps' || arg === '--app');
+
+  const moduleModeArgs = libsArg || packagesArg || appsArg;
 
-  const index = process.argv.indexOf(packagesArg);
+  if (!moduleModeArgs) return discoverModules(false);
+
+  const index = process.argv.indexOf(moduleModeArgs);
   const rawValue = process.argv[index + 1] || '';
-  const packageNames = rawValue
+
+  const modulePatterns = 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);
+  /** @type {ModuleDescriptor[]} */
+  const modules = [];
+
+  for (const modulePattern of modulePatterns) {
+    const discoveredModule = getModule(modulePattern, !!libsArg);
+    if (discoveredModule) {
+      modules.push(discoveredModule);
     } else {
-      logError(`❌ Package ${pkgName} → app folder ${folder} not found, skipping`);
+      logError(
+        `❌ Module ${modulePattern} → folder ${discoveredModule?.shortPath || 'unknown'} not found, skipping`,
+      );
     }
   }
 
   logInfo(
-    `Running in packages mode for: ${packageNames.join(', ')} → apps: ${mappedFolders.join(', ')}`,
+    `patterns ${modulePatterns.join(', ')} → folders: ${modules
+      .map((item) => item.fullPath)
+      .join(', ')}`,
   );
-  return { appFolders: mappedFolders, packageNames };
-}
 
-/**
- * Discover all React apps in the apps directory when no CLI flags are provided.
- *
- * Only apps that contain a `package.json` file and are identified as React apps
- * (via `isReactApp`) will be included.
- *
- * @param {string} appsDir - Absolute path to the apps root directory.
- * @returns {{appFolders: string[], packageNames: string[]}}
- *   Object containing discovered app folders and an empty `packageNames` array.
- */
-function discoverApps(appsDir) {
-  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: [] };
+  return modules;
 }
 
 /**
- * Parse CLI arguments to resolve which apps or packages should be analyzed.
+ * Alias for {@link parseArgs}, used for semantic clarity in CLI entrypoints.
+ *
+ * This function simply delegates to {@link parseArgs} and returns the same result.
  *
- * Priority order:
- *  1. Explicit `--apps` flag
- *  2. Explicit `--packages` flag
- *  3. Auto-discovery fallback
+ * @returns {ModuleDescriptor[] | null}
+ * Array of resolved module descriptors, or `null` if no valid flags were provided.
  *
- * @param {string} appsDir - Absolute path to the apps root directory.
- * @returns {{appFolders: string[], packageNames: string[]}}
- *   Object containing app folder names and package names for analysis.
+ * @example
+ * parseCliTargets();
+ * // Equivalent to parseArgs(), typically used in CLI commands.
  */
-export function parseCliTargets(appsDir) {
-  return parseAppsArg(appsDir) || parsePackagesArg(appsDir) || discoverApps(appsDir);
+export function parseCliTargets() {
+  return parseArgs();
 }
 
 /**

package/bin/utils/module-utils.js

@@ -0,0 +1,121 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+import { appsDir, librariesBasePaths, staticDiscoveredLibraries } from '../cli-path-config.js';
+import { readJsonSafe } from './file-utils.js';
+import { logWarn } from './log-utils.js';
+
+/**
+ * Determine whether a given package directory represents a React-based module.
+ *
+ * This function inspects the `package.json` file located at `pkgPath`
+ * and checks whether any of its dependencies, devDependencies, or peerDependencies
+ * include `react`. If the file does not exist, cannot be parsed, or the
+ * dependency is missing, it returns `false`.
+ *
+ * @param {string} pkgPath - Absolute path to a `package.json` file.
+ * @returns {boolean} `true` if the module depends on React, otherwise `false`.
+ *
+ * @example
+ * isReactModule('/path/to/package.json');
+ * // → true if the package declares React as a dependency
+ */
+export function isReactModule(pkgPath) {
+  try {
+    if (!fs.existsSync(pkgPath)) return false;
+
+    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;
+  }
+}
+
+/**
+ * Discover all valid application or library modules by scanning predefined directories.
+ *
+ * Depending on the `isLibrary` flag, this function inspects:
+ * - Libraries under: `packages/manager/core`, `packages/manager/modules`, and `packages/components`
+ * - Applications under: `manager/apps`
+ *
+ * For each folder containing a `package.json` that represents a React module,
+ * a module descriptor object is created with metadata.
+ *
+ * @param {boolean} [isLibrary=false] - Whether to scan for libraries (`true`) or apps (`false`).
+ * @returns {Array<{ fullPath: string, shortPath: string, packageName: string }>}
+ * Array of discovered module descriptors.
+ *
+ * @example
+ * // Discover apps
+ * discoverModules();
+ * // → [{ fullPath: '/.../manager/apps/zimbra', shortPath: 'zimbra', packageName: '@ovh-ux/manager-zimbra-app' }]
+ *
+ * @example
+ * // Discover libraries
+ * discoverModules(true);
+ * // → [{ fullPath: '/.../packages/manager/core/core-shell', shortPath: 'core-shell', packageName: '@ovh-ux/manager-core-shell' }]
+ */
+export function discoverModules(isLibrary = false) {
+  const discovered = [];
+  const modulesPaths = isLibrary ? librariesBasePaths : [appsDir];
+
+  for (const moduleBasePath of modulesPaths) {
+    if (!fs.existsSync(moduleBasePath)) continue;
+
+    const items = fs.readdirSync(moduleBasePath, { withFileTypes: true });
+    for (const item of items) {
+      if (item.isDirectory()) {
+        const appFolder = path.join(moduleBasePath, item.name);
+        const pkgPath = path.join(appFolder, 'package.json');
+        if (fs.existsSync(pkgPath) && isReactModule(pkgPath)) {
+          const pkgDetails = readJsonSafe(pkgPath);
+          discovered.push({
+            fullPath: appFolder,
+            shortPath: item.name,
+            packageName: pkgDetails.name,
+          });
+        }
+      }
+    }
+  }
+
+  return isLibrary ? [...discovered, ...staticDiscoveredLibraries] : discovered;
+}
+
+/**
+ * Retrieve a single module (app or library) matching a given pattern.
+ *
+ * This function searches through discovered modules (via {@link discoverModules})
+ * and returns the first one matching any of the following:
+ * - The module's absolute path (`fullPath`)
+ * - The folder name (`shortPath`)
+ * - The npm package name (`packageName`)
+ *
+ * @param {string} modulePattern - Pattern to match against module identifiers.
+ * @param {boolean} [isLibrary=false] - Whether to search within libraries (`true`) or apps (`false`).
+ * @returns {{ fullPath: string, shortPath: string, packageName: string }}
+ * The matched module descriptor, or `undefined` if no match is found.
+ *
+ * @example
+ * // Match by folder name
+ * getModule('zimbra');
+ * // → { fullPath: '/.../manager/apps/zimbra', shortPath: 'zimbra', packageName: '@ovh-ux/manager-zimbra-app' }
+ *
+ * @example
+ * // Match by package name
+ * getModule('@ovh-ux/manager-core-shell', true);
+ * // → { fullPath: '/.../packages/manager/core/core-shell', shortPath: 'core-shell', packageName: '@ovh-ux/manager-core-shell' }
+ */
+export function getModule(modulePattern, isLibrary = false) {
+  const discoveredLibraries = discoverModules(isLibrary) || [];
+  return discoveredLibraries.find(
+    (library) =>
+      library.fullPath === modulePattern ||
+      library.shortPath === modulePattern ||
+      library.packageName === modulePattern,
+  );
+}

package/bin/utils/runner-utils.js

@@ -3,12 +3,23 @@ import fs from 'node:fs';
 import path from 'node:path';
 import process from 'node:process';
 
-import { resolveAppInfo } from './apps-utils.js';
-import { generateCombinedReports } from './file-utils.js';
+import { generateCombinedReports, readJsonSafe } from './file-utils.js';
 import { logError, logInfo } from './log-utils.js';
+import { isReactModule } from './module-utils.js';
 
 /**
- * Ensure the given binary exists.
+ * Ensure that a required binary exists before running an analysis command.
+ *
+ * This function verifies that a binary file exists at the given path.
+ * If not found, it logs an error message and terminates the process
+ * with exit code `1`.
+ *
+ * @param {string} binPath - Absolute path to the binary executable.
+ * @param {string} label - Human-readable label for the binary (used in error logs).
+ *
+ * @example
+ * ensureBinExists('/usr/local/bin/jscpd', 'JSCPD');
+ * // → Exits process if binary is missing
  */
 export function ensureBinExists(binPath, label) {
   if (!fs.existsSync(binPath)) {
@@ -18,7 +29,20 @@ export function ensureBinExists(binPath, label) {
 }
 
 /**
- * Run a child process with consistent defaults.
+ * Execute a command synchronously using the system shell.
+ *
+ * This function spawns a child process that runs a binary or command
+ * with the provided arguments, inheriting the parent process's stdio streams.
+ * It returns `true` if the command completed successfully (exit code `0`).
+ *
+ * @param {string} bin - Executable name or absolute path to run.
+ * @param {string[]} args - Command-line arguments for the executable.
+ * @param {string} cwd - Working directory where the command will be executed.
+ * @returns {boolean} `true` if the process exits with status `0`, otherwise `false`.
+ *
+ * @example
+ * runCommand('eslint', ['--fix', '.'], process.cwd());
+ * // → Runs ESLint and returns true if successful
  */
 export function runCommand(bin, args, cwd) {
   const result = spawnSync(bin, args, {
@@ -30,14 +54,90 @@ export function runCommand(bin, args, cwd) {
 }
 
 /**
- * Generic per-app analysis runner with safety.
+ * Execute analysis for a single module.
+ *
+ * This internal helper encapsulates:
+ *  - Module validation (`fullPath`, `package.json`, React module check)
+ *  - Error handling for analysis execution
+ *  - Delegation to a provided analysis runner
+ *
+ * @param {Object} options - Analysis parameters.
+ * @param {Object} options.module - Module descriptor with metadata.
+ * @param {Function} options.analysisRunner - Function `(fullPath, shortPath, context) => boolean`
+ *   that performs the analysis for this module.
+ * @returns {boolean} `true` if analysis succeeded for the module, otherwise `false`.
+ *
+ * @example
+ * runModuleAnalysis({
+ *   module: { fullPath: '/apps/zimbra', shortPath: 'zimbra', packageName: '@ovh-ux/manager-zimbra-app' },
+ *   analysisRunner: runCoverageAnalysis,
+ * });
  */
-export function runAppsAnalysis({
-  appsDir,
-  appFolders,
-  requireReact = false,
+function runModuleAnalysis({ module, analysisRunner }) {
+  const { fullPath, shortPath, packageName } = module || {};
+  const pkgPath = path.join(fullPath, 'package.json');
+  let isAnalysisComplete = false;
+
+  if (!fs.existsSync(fullPath) || !fs.existsSync(pkgPath) || !isReactModule(pkgPath)) {
+    logError(`❌ Module folder not found: ${module} → skipping`);
+    return isAnalysisComplete;
+  }
+
+  try {
+    isAnalysisComplete = analysisRunner(fullPath, shortPath, {
+      pkgPath,
+      moduleDir: fullPath,
+      moduleFolder: shortPath,
+      moduleShortName: packageName,
+      pkg: readJsonSafe(pkgPath),
+    });
+  } catch (err) {
+    logError(`❌ Fatal error while analyzing ${shortPath}: ${err.stack || err.message}`);
+  }
+
+  return isAnalysisComplete;
+}
+
+/**
+ * Run a complete analysis across multiple modules and generate combined reports.
+ *
+ * This function orchestrates:
+ *  1. Iterating over provided modules.
+ *  2. Running analysis for each module (via `runModuleAnalysis`).
+ *  3. Aggregating successful results.
+ *  4. Generating combined JSON and HTML reports.
+ *
+ * If no modules are successfully analyzed, the process terminates with exit code `1`.
+ *
+ * @param {Object} options - Analysis configuration.
+ * @param {Object[]} options.modules - Array of module descriptors (`{ fullPath, shortPath, packageName }`).
+ * @param {string} options.binaryLabel - Label for the analysis type (e.g. "Type Coverage").
+ * @param {Function} options.analysisRunner - Function executed per module to run analysis logic.
+ * @param {string} options.reportsRootDirName - Directory under the output root to store reports.
+ * @param {string} options.combinedJson - Filename for the combined JSON report.
+ * @param {string} options.combinedHtml - Filename for the combined HTML report.
+ * @param {Function} options.collectFn - Function used to aggregate individual module data.
+ * @param {Function} options.generateHtmlFn - Function used to generate the combined HTML output.
+ * @param {string} options.outputRootDir - Base path where reports should be written.
+ * @returns {string[]} Array of successfully analyzed module short names.
+ *
+ * @example
+ * runModulesAnalysis({
+ *   modules,
+ *   binaryLabel: 'Type Coverage',
+ *   analysisRunner: runTypeCoverage,
+ *   reportsRootDirName: 'types-coverage-reports',
+ *   combinedJson: 'types-coverage-combined-report.json',
+ *   combinedHtml: 'types-coverage-combined-report.html',
+ *   collectFn: collectTypeCoverage,
+ *   generateHtmlFn: generateTypeCoverageHtml,
+ *   outputRootDir: './reports',
+ * });
+ */
+export function runModulesAnalysis({
+  modules,
   binaryLabel,
-  appRunner, // (appDir, appShortName, appInfo) => boolean
+  analysisRunner,
   reportsRootDirName,
   combinedJson,
   combinedHtml,
@@ -45,21 +145,16 @@ export function runAppsAnalysis({
   generateHtmlFn,
   outputRootDir,
 }) {
+  /** @type {string[]} */
   const analyzed = [];
 
-  for (const appFolder of appFolders) {
-    const appInfo = resolveAppInfo(appsDir, appFolder, { requireReact });
-    if (!appInfo) continue;
+  for (const module of modules) {
+    const isAnalysisComplete = runModuleAnalysis({
+      module,
+      analysisRunner,
+    });
 
-    let ok = false;
-    try {
-      ok = appRunner(appInfo.appDir, appInfo.appShortName, appInfo);
-    } catch (err) {
-      logError(
-        `❌ Fatal error while analyzing ${appInfo.appShortName}: ${err.stack || err.message}`,
-      );
-    }
-    if (ok) analyzed.push(appInfo.appShortName);
+    if (isAnalysisComplete) analyzed.push(module.shortPath);
   }
 
   if (analyzed.length > 0) {

package/bin/utils/turbo-utils.js

@@ -1,76 +1,6 @@
 import { spawnSync } from 'node:child_process';
-import fs from 'node:fs';
-import path from 'node:path';
 
-import { logError, logInfo, logWarn } from './log-utils.js';
-
-/**
- * Convert app folder names into Turbo filters by resolving their package.json names.
- *
- * Each app folder must contain a valid `package.json`. If not found, the app is skipped.
- *
- * @param {string} appsDir - Absolute path to the apps root directory.
- * @param {string[]} appFolders - List of app folder names inside the apps directory.
- * @returns {string[]} Array of package names to be used as Turbo filters.
- *
- * @example
- * // appsDir = "/workspace/manager/apps"
- * // appFolders = ["zimbra", "web"]
- * // Returns: ["@ovh-ux/manager-zimbra-app", "@ovh-ux/manager-web-app"]
- */
-function resolveTurboFiltersFromAppFolders(appsDir, 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);
-}
-
-/**
- * Resolve Turbo filters (package names) based on input mode.
- *
- * - If only `appFolders` are provided, resolves their corresponding package names.
- * - If `packageNames` are provided, they are used directly as filters.
- *
- * @param {Object} options
- * @param {string} options.appsDir - Absolute path to the apps root directory.
- * @param {string[]} options.appFolders - List of app folders to analyze.
- * @param {string[]} options.packageNames - List of package names (overrides appFolders).
- * @returns {string[]} List of resolved Turbo filters (package names).
- *
- * @example
- * resolveTurboFilters({
- *   appsDir: "/workspace/manager/apps",
- *   appFolders: ["zimbra"],
- *   packageNames: []
- * });
- * // → ["@ovh-ux/manager-zimbra-app"]
- *
- * @example
- * resolveTurboFilters({
- *   appsDir: "/workspace/manager/apps",
- *   appFolders: [],
- *   packageNames: ["@ovh-ux/manager-web-app"]
- * });
- * // → ["@ovh-ux/manager-web-app"]
- */
-export function resolveTurboFilters({ appsDir, appFolders, packageNames }) {
-  let filters = [];
-
-  if (appFolders.length > 0 && packageNames.length === 0) {
-    filters = resolveTurboFiltersFromAppFolders(appsDir, appFolders);
-  } else if (packageNames.length > 0) {
-    filters = packageNames;
-  }
-
-  return filters;
-}
+import { logInfo, logWarn } from './log-utils.js';
 
 /**
  * Run a Turbo build for the provided filters.

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

@@ -1 +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;AAKtE,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAO9C;AAmCD,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,WAAW,EAAE,GAAG,YAAY,CAgBlE;AASD,wBAAgB,kBAAkB,CAAC,eAAe,EAAE,MAAM,GAAG,kBAAkB,CAmC9E;AASD,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,kBAAkB,GAAG,MAAM,CAwJ3E"}
+{"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;AAKtE,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAO9C;AAyCD,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,WAAW,EAAE,GAAG,YAAY,CAgBlE;AASD,wBAAgB,kBAAkB,CAAC,eAAe,EAAE,MAAM,GAAG,kBAAkB,CAmC9E;AASD,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,kBAAkB,GAAG,MAAM,CAwJ3E"}

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

@@ -15,14 +15,18 @@ const buildAssetsInfos = (data) => data.map((entry) => {
     const filename = entry?.filename ?? 'unknown';
     const sizeKb = typeof entry?.parsedSize === 'number' ? entry.parsedSize / 1024 : 0;
     let type = 'other';
-    if (/\.js$/i.test(filename))
+    if (/\.(js|mjs|cjs|ts|tsx)$/i.test(filename)) {
         type = 'js';
-    else if (/\.css$/i.test(filename))
+    }
+    else if (/\.css$/i.test(filename)) {
         type = 'css';
-    else if (/\.html$/i.test(filename))
+    }
+    else if (/\.html?$/i.test(filename)) {
         type = 'html';
-    else if (/\.(png|jpe?g|gif|svg|webp)$/i.test(filename))
+    }
+    else if (/\.(png|jpe?g|gif|svg|webp)$/i.test(filename)) {
         type = 'img';
+    }
     return { filename, type, sizeKb };
 });
 export function parseAnalyzerJson(raw) {

package/dist/configs/shared-exclusion-patterns.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shared-exclusion-patterns.d.ts","sourceRoot":"","sources":["../../src/configs/shared-exclusion-patterns.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,uBAAuB,UAuCnC,CAAC;AAyBF,eAAO,MAAM,4BAA4B,UAuBxC,CAAC"}
+{"version":3,"file":"shared-exclusion-patterns.d.ts","sourceRoot":"","sources":["../../src/configs/shared-exclusion-patterns.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,uBAAuB,UAuCnC,CAAC;AAyBF,eAAO,MAAM,4BAA4B,UAwBxC,CAAC"}

package/dist/configs/shared-exclusion-patterns.js

@@ -53,6 +53,7 @@ export const sharedTypesExclusionPatterns = [
     '**/tailwind*.*',
     '**/turbo.json',
     '**/tsconfig.json',
+    'vite-env.d.ts',
     '**/*.svg',
     '**/**.md',
     '**/Messages_*_*.json',