Reworked detection of unused referenced components

Author: thim81

openapi-format.js

@@ -245,7 +245,7 @@ async function openapiFilter(oaObj, options) {
     }
 
     // Register components usage
-    if (this.key === '$ref') {
+    if (this.key === '$ref' && typeof node === 'string') {
       if (node.startsWith('#/components/schemas/')) {
         const compSchema = node.replace('#/components/schemas/', '');
         comps.schemas[compSchema] = {...comps.schemas[compSchema], used: true};
@@ -647,63 +647,56 @@ async function openapiFilter(oaObj, options) {
   unusedComp.requestBodies = Object.keys(comps.requestBodies || {}).filter(key => !comps.requestBodies[key].used);
   unusedComp.headers = Object.keys(comps.headers || {}).filter(key => !comps.headers[key].used);
 
-  // Identify components that are only used by other unused components
-  let foundNewUnused = true;
-  while (foundNewUnused) {
-    foundNewUnused = false;
-
-    // Check each component type
-    for (const compType of ['schemas', 'responses', 'parameters', 'examples', 'requestBodies', 'headers']) {
-      // Get all components of this type that are currently marked as used
-      const usedComps = Object.keys(comps[compType] || {}).filter(
-        key => comps[compType][key].used && !unusedComp[compType].includes(key)
-      );
-
-      // For each used component, check if it's only used by unused components
-      for (const compKey of usedComps) {
-        let isOnlyUsedByUnusedComps = true;
-
-        // Check if this component is used in paths (directly used)
-        traverse(jsonObj.paths || {}).forEach(function (node) {
-          if (this.key === '$ref' && node === `#/components/${compType}/${compKey}`) {
-            isOnlyUsedByUnusedComps = false;
-            this.stop();
-          }
-        });
-
-        if (isOnlyUsedByUnusedComps) {
-          // Check if this component is used by any component that is not in the unused list
-          for (const otherCompType of ['schemas', 'responses', 'parameters', 'examples', 'requestBodies', 'headers']) {
-            const otherUsedComps = Object.keys(comps[otherCompType] || {}).filter(
-              key => comps[otherCompType][key].used && !unusedComp[otherCompType].includes(key)
-            );
-
-            for (const otherCompKey of otherUsedComps) {
-              if (otherCompKey === compKey && otherCompType === compType) continue; // Skip self-reference
+  const refGraph = { schemas:{}, responses:{}, parameters:{},
+    examples:{}, requestBodies:{}, headers:{} };
+  const rootRefs = new Set();
 
-              traverse(jsonObj.components?.[otherCompType]?.[otherCompKey] || {}).forEach(function (node) {
-                if (this.key === '$ref' && node === `#/components/${compType}/${compKey}`) {
-                  isOnlyUsedByUnusedComps = false;
-                  this.stop();
-                }
-              });
-
-              if (!isOnlyUsedByUnusedComps) break;
-            }
-
-            if (!isOnlyUsedByUnusedComps) break;
-          }
-        }
+  traverse(jsonObj).forEach(function(node) {
+    if (this.key !== '$ref' || typeof node !== 'string') return;
+    const m = node.match(/^#\/components\/([^\/]+)\/(.+)$/);
+    if (!m) return;
+    const [, tgtType, tgtKey] = m;
+    if (this.path[0] === 'components') {
+      const [ , ownType, ownKey ] = this.path;
+      refGraph[ownType]      ||= {};
+      refGraph[ownType][ownKey] ||= [];
+      refGraph[ownType][ownKey].push({ type: tgtType, key: tgtKey });
+    } else {
+      rootRefs.add(`${tgtType}:${tgtKey}`);
+    }
+  });
 
-        // If this component is only used by unused components, mark it as unused
-        if (isOnlyUsedByUnusedComps) {
-          unusedComp[compType].push(compKey);
-          foundNewUnused = true;
-        }
-      }
+  // 2) BFS to mark all reachable components
+  const visited = new Set();
+  const queue   = [...rootRefs];
+  while (queue.length) {
+    const id = queue.shift();
+    if (visited.has(id)) continue;
+    visited.add(id);
+    const [type, key] = id.split(':');
+    const edges = (refGraph[type] && refGraph[type][key]) || [];
+    for (const {type: ct, key: ck} of edges) {
+      const childId = `${ct}:${ck}`;
+      if (!visited.has(childId)) queue.push(childId);
     }
   }
 
+  // 3) collect everything *not* visited as unused
+  // const unusedComp = { schemas:[], responses:[], parameters:[], examples:[], requestBodies:[], headers:[] };
+  for (const t of ['schemas','responses','parameters','examples','requestBodies','headers']) {
+    unusedComp[t] = Object
+      .keys(comps[t]||{})
+      .filter(k => !visited.has(`${t}:${k}`));
+  }
+  unusedComp.meta = {
+    total: unusedComp.schemas.length
+         + unusedComp.responses.length
+         + unusedComp.parameters.length
+         + unusedComp.examples.length
+         + unusedComp.requestBodies.length
+         + unusedComp.headers.length
+  };
+
   // Update options.unusedComp with the newly identified unused components
   if (optFs.includes('schemas')) options.unusedComp.schemas = [...options.unusedComp.schemas, ...unusedComp.schemas];
   if (optFs.includes('responses'))