@thumbmarkjs/thumbmarkjs 1.7.2 → 1.7.4

package/src/functions/filterComponents.ts

@@ -12,62 +12,48 @@ import { getBrowser } from "../components/system/browser";
  * @param options - Filtering options
  * @returns Filtered object
  */
-export function filterThumbmarkData(
-    obj: componentInterface,
-    options?: optionsInterface,
-): componentInterface {
-    // Get current browser name and version
+/**
+ * Builds the full exclusion list from user options and stabilization rules,
+ * taking browser detection into account.
+ */
+export function getExcludeList(options?: optionsInterface, obj?: componentInterface): string[] {
     let browser = getBrowser();
-    
-    // Fallback to browser info from components if getBrowser() returns unknown (server-side)
-    if (browser.name === 'unknown' && obj.system && typeof obj.system === 'object' && !Array.isArray(obj.system)) {
-        const systemComponent = obj.system as componentInterface;
-        const browserInfo = systemComponent.browser;
-        if (browserInfo && typeof browserInfo === 'object' && !Array.isArray(browserInfo)) {
-            const browserComponent = browserInfo as componentInterface;
-            browser = {
-                name: (browserComponent.name as string) || 'unknown',
-                version: (browserComponent.version as string) || 'unknown'
-            };
-        }
+
+    // Fallback to component data when getBrowser() returns unknown (server-side)
+    if (browser.name === 'unknown' && obj) {
+        const b = (obj.system as componentInterface)?.browser as componentInterface | undefined;
+        if (b?.name) browser = { name: String(b.name), version: String(b.version || 'unknown') };
     }
-    
-    const name = browser.name.toLowerCase();
-    const ver = browser.version.split('.')[0] || '0';
-    const majorVer = parseInt(ver, 10);
 
-    // Initialize excludeList with user-defined exclusions from options
+    const name = browser.name.toLowerCase();
+    const majorVer = parseInt(browser.version.split('.')[0] || '0', 10);
     const excludeList = [...(options?.exclude || [])];
-    const stabilizationOptions = options?.stabilize || [];
-    const includeList = options?.include || [];
+    const stabilizationOptions = [...new Set([...(options?.stabilize || []), 'always'])];
 
-    // Expand the excludeList based on stabilization rules
     for (const option of stabilizationOptions) {
         const rules = stabilizationExclusionRules[option as keyof typeof stabilizationExclusionRules];
         if (!rules) continue;
 
         for (const rule of rules) {
-            // A rule applies to all browsers if the 'browsers' key is not present.
-            const appliesToAllBrowsers = !('browsers' in rule);
-
-            // The 'rule.browsers?' optional chaining here safely handles the case where 'browsers' is missing.
-            const browserMatch = !appliesToAllBrowsers && rule.browsers?.some(browserRule => {
-                const match = browserRule.match(/(.+?)(>=)(\d+)/);
-                
-                if (match) {
-                    const [, ruleName, , ruleVersionStr] = match;
-                    const ruleVersion = parseInt(ruleVersionStr, 10);
-                    return name === ruleName && majorVer >= ruleVersion;
-                }
-                return name === browserRule;
-            });
-
-            if (appliesToAllBrowsers || browserMatch) {
+            if (!('browsers' in rule) || rule.browsers?.some(br => {
+                const m = br.match(/(.+?)(>=)(\d+)/);
+                return m ? name === m[1] && majorVer >= +m[3] : name === br;
+            })) {
                 excludeList.push(...rule.exclude);
             }
         }
     }
 
+    return excludeList;
+}
+
+export function filterThumbmarkData(
+    obj: componentInterface,
+    options?: optionsInterface,
+): componentInterface {
+    const excludeList = getExcludeList(options, obj);
+    const includeList = options?.include || [];
+
     /**
      * Inner recursive function to perform the actual filtering.
      * Uses the fully prepared excludeList and includeList from the parent scope.

package/src/functions/index.ts

@@ -18,7 +18,7 @@ import {
 import { hash } from "../utils/hash";
 import { raceAllPerformance } from "../utils/raceAll";
 import { getVersion } from "../utils/version";
-import { filterThumbmarkData } from './filterComponents'
+import { filterThumbmarkData, getExcludeList } from './filterComponents'
 import { logThumbmarkData } from '../utils/log';
 import { getApiPromise, infoInterface } from "./api";
 import { stableStringify } from "../utils/stableStringify";
@@ -180,8 +180,10 @@ export async function resolveClientComponents(
   options?: optionsInterface
 ): Promise<{ elapsed: Record<string, number>, resolvedComponents: componentInterface, errors: ThumbmarkError[] }> {
   const opts = { ...defaultOptions, ...options };
+  const topLevelExcludes = getExcludeList(opts).filter(e => !e.includes('.'));
   const filtered = Object.entries(comps)
     .filter(([key]) => !opts?.exclude?.includes(key))
+    .filter(([key]) => !topLevelExcludes.includes(key))
     .filter(([key]) =>
       opts?.include?.some(e => e.includes('.'))
         ? opts?.include?.some(e => e.startsWith(key))

package/src/options.ts

@@ -97,4 +97,7 @@ export const stabilizationExclusionRules = {
     'vpn': [
         { exclude: ['ip'] },
     ],
+    'always': [
+        { exclude: ['speech'], browsers: ['brave', 'firefox'] },
+    ],
 }