Remove fixDanglingRefs() and cross-file reference test

The fixDanglingRefs() function was handling invalid OpenAPI/JSON Schema usage where external files use local-looking refs (e.g., #/components/schemas/SchemaB) to reference schemas in other external files.

Per JSON Schema and OpenAPI specifications, a ref starting with # is a local reference to the current document only. Cross-file references must use proper relative or absolute URIs.

Removed:
- fixDanglingRefs() function from bundle.ts
- Cross-file reference test case
- Test spec files: cross-file-ref-*.json
- Associated snapshot file

Invalid specs should fail with clear errors rather than being silently "fixed". Users with such specs should be asked to use correct syntax like "file2.json#/components/schemas/SchemaB".

Co-authored-by: mrlubos <[e-mail]>

packages/json-schema-ref-parser/src/__tests__/__snapshots__/cross-file-ref-main.json

···
-{
-  "openapi": "3.0.0",
-  "info": {
-    "title": "Cross-file Reference Test",
-    "version": "1.0.0"
-  },
-  "paths": {
-    "/resource-a": {
-      "get": {
-        "responses": {
-          "200": {
-            "description": "Returns SchemaA",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "$ref": "#/components/schemas/SchemaA"
-                }
-              }
-            }
-          }
-        }
-      }
-    },
-    "/resource-b": {
-      "get": {
-        "responses": {
-          "200": {
-            "description": "Returns SchemaB",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "$ref": "#/components/schemas/SchemaB"
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  },
-  "components": {
-    "schemas": {
-      "SchemaA": {
-        "type": "object",
-        "properties": {
-          "typeField": {
-            "$ref": "#/components/schemas/SchemaB"
-          },
-          "name": {
-            "type": "string"
-          }
-        }
-      },
-      "SchemaB": {
-        "type": "string",
-        "enum": [
-          "TypeA",
-          "TypeB",
-          "TypeC"
-        ]
-      }
-    }
-  }
-}

packages/json-schema-ref-parser/src/__tests__/bundle.test.ts

···
 
     await expectBundledSchemaToMatchSnapshot(schema, 'redfish-like.json');
   });
-
-  it('fixes cross-file references (schemas in different external files)', async () => {
-    const refParser = new $RefParser();
-    const pathOrUrlOrSchema = path.join(
-      getSpecsPath(),
-      'json-schema-ref-parser',
-      'cross-file-ref-main.json',
-    );
-    const schema = await refParser.bundle({ pathOrUrlOrSchema });
-
-    await expectBundledSchemaToMatchSnapshot(schema, 'cross-file-ref-main.json');
-  });
 });

packages/json-schema-ref-parser/src/bundle.ts

···
 }
 
 /**
- * Fix dangling $refs that point to schemas in the root spec but don't exist.
- * This can happen when an external file references another external file's schema
- * using a local-looking ref like #/components/schemas/SchemaName.
- *
- * @param parser
- */
-function fixDanglingRefs(parser: $RefParser): void {
-  const root = parser.schema as any;
-  if (!root || typeof root !== 'object') {
-    return;
-  }
-
-  // Get all hoisted schemas from components
-  const containers = [
-    { obj: root.components?.schemas, prefix: '#/components/schemas/' },
-    { obj: root.components?.parameters, prefix: '#/components/parameters/' },
-    { obj: root.components?.requestBodies, prefix: '#/components/requestBodies/' },
-    { obj: root.components?.responses, prefix: '#/components/responses/' },
-    { obj: root.components?.headers, prefix: '#/components/headers/' },
-    { obj: root.definitions, prefix: '#/definitions/' },
-    { obj: root.parameters, prefix: '#/parameters/' },
-    { obj: root.responses, prefix: '#/responses/' },
-  ].filter((c) => c.obj && typeof c.obj === 'object');
-
-  // Build a map of simple schema names to their hoisted full names
-  // Since we now use unprefixed names when there's no conflict, we need to handle both cases
-  const schemaNameMap = new Map<string, Array<{ fullName: string; prefix: string }>>();
-
-  for (const container of containers) {
-    for (const fullName of Object.keys(container.obj)) {
-      // First, add the full name itself as a candidate (for unprefixed schemas)
-      if (!schemaNameMap.has(fullName)) {
-        schemaNameMap.set(fullName, []);
-      }
-      schemaNameMap.get(fullName)!.push({
-        fullName,
-        prefix: container.prefix,
-      });
-
-      // Extract the original schema name from the hoisted name if it has a prefix
-      // Hoisted names with conflicts are "filename_SchemaName"
-      // Try to match the pattern and extract SchemaName
-      const parts = fullName.split('_');
-      if (parts.length >= 2) {
-        // The last part(s) might be the original schema name
-        // Try progressively longer suffixes
-        for (let i = 1; i < parts.length; i++) {
-          const schemaName = parts.slice(i).join('_');
-          if (!schemaNameMap.has(schemaName)) {
-            schemaNameMap.set(schemaName, []);
-          }
-          schemaNameMap.get(schemaName)!.push({
-            fullName,
-            prefix: container.prefix,
-          });
-        }
-      }
-    }
-  }
-
-  // Find and fix all dangling $refs
-  const fixRefs = (obj: any, visited = new WeakSet<object>()): void => {
-    if (!obj || typeof obj !== 'object' || ArrayBuffer.isView(obj)) {
-      return;
-    }
-
-    if (visited.has(obj)) {
-      return;
-    }
-    visited.add(obj);
-
-    if ($Ref.is$Ref(obj)) {
-      const ref = obj.$ref;
-      if (typeof ref === 'string') {
-        // Check if this is a dangling internal ref
-        for (const container of containers) {
-          if (ref.startsWith(container.prefix)) {
-            const schemaName = ref.substring(container.prefix.length);
-
-            // Check if the exact name exists
-            if (container.obj[schemaName]) {
-              continue; // Not dangling
-            }
-
-            // Try to find a hoisted schema that matches this name
-            const candidates = schemaNameMap.get(schemaName) || [];
-
-            if (candidates.length === 1) {
-              // Unambiguous match - fix the ref
-              const candidate = candidates[0]!;
-              obj.$ref = `${candidate.prefix}${candidate.fullName}`;
-              console.warn(`Fixed dangling $ref: ${ref} -> ${obj.$ref}`);
-            } else if (candidates.length > 1) {
-              // Multiple matches - log warning but don't change
-              console.warn(
-                `Ambiguous dangling $ref: ${ref} could refer to: ${candidates.map((c) => `${c.prefix}${c.fullName}`).join(', ')}`,
-              );
-            }
-            // If no candidates, leave as-is (will remain dangling)
-          }
-        }
-      }
-    }
-
-    // Recursively fix refs in nested objects
-    for (const value of Object.values(obj)) {
-      fixRefs(value, visited);
-    }
-  };
-
-  fixRefs(root);
-}
-
-/**
  * Bundles all external JSON references into the main JSON schema, thus resulting in a schema that
  * only has *internal* references, not any *external* references.
  * This method mutates the JSON schema object, adding new references and re-mapping existing ones.
···
   });
 
   remap(parser, inventory);
-  fixDanglingRefs(parser);
 }

specs/json-schema-ref-parser/cross-file-ref-file1.json

···
-{
-  "components": {
-    "schemas": {
-      "SchemaA": {
-        "type": "object",
-        "properties": {
-          "typeField": {
-            "$ref": "#/components/schemas/SchemaB"
-          },
-          "name": {
-            "type": "string"
-          }
-        }
-      }
-    }
-  }
-}

specs/json-schema-ref-parser/cross-file-ref-file2.json

···
-{
-  "components": {
-    "schemas": {
-      "SchemaB": {
-        "type": "string",
-        "enum": ["TypeA", "TypeB", "TypeC"]
-      }
-    }
-  }
-}

specs/json-schema-ref-parser/cross-file-ref-main.json

···
-{
-  "openapi": "3.0.0",
-  "info": {
-    "title": "Cross-file Reference Test",
-    "version": "1.0.0"
-  },
-  "paths": {
-    "/resource-a": {
-      "get": {
-        "responses": {
-          "200": {
-            "description": "Returns SchemaA",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "$ref": "cross-file-ref-file1.json#/components/schemas/SchemaA"
-                }
-              }
-            }
-          }
-        }
-      }
-    },
-    "/resource-b": {
-      "get": {
-        "responses": {
-          "200": {
-            "description": "Returns SchemaB",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "$ref": "cross-file-ref-file2.json#/components/schemas/SchemaB"
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-}