swagger-client 3.22.3 → 3.23.0

package/es/resolver/apidom/reference/dereference/strategies/openapi-3-1-swagger-client/utils/to-path.js

@@ -1,4 +1,4 @@
-import { isMemberElement, isArrayElement } from '@swagger-api/apidom-core';
+import { isMemberElement, isArrayElement, toValue } from '@swagger-api/apidom-core';
 const trimParseResult = elementPath => elementPath.slice(2);
 
 /**
@@ -11,7 +11,7 @@ const toPath = elementPath => {
   const elementPathSanitized = trimParseResult(elementPath);
   return elementPathSanitized.reduce((path, element, index) => {
     if (isMemberElement(element)) {
-      const token = String(element.key.toValue());
+      const token = String(toValue(element.key));
       path.push(token);
     } else if (isArrayElement(elementPathSanitized[index - 2])) {
       const token = elementPathSanitized[index - 2].content.indexOf(element);

package/es/resolver/apidom/reference/dereference/strategies/openapi-3-1-swagger-client/visitors/all-of.js

@@ -1,4 +1,4 @@
-import { isArrayElement, deepmerge } from '@swagger-api/apidom-core';
+import { isArrayElement, deepmerge, cloneDeep, toValue } from '@swagger-api/apidom-core';
 import { isSchemaElement, SchemaElement } from '@swagger-api/apidom-ns-openapi-3-1';
 import compose from '../utils/compose.js';
 import toPath from '../utils/to-path.js';
@@ -27,7 +27,7 @@ const AllOfVisitor = compose({
 
         // remove allOf keyword if empty
         if (schemaElement.allOf.isEmpty) {
-          return new SchemaElement(schemaElement.content.filter(memberElement => memberElement.key.toValue() !== 'allOf'), schemaElement.meta.clone(), schemaElement.attributes.clone());
+          return new SchemaElement(schemaElement.content.filter(memberElement => toValue(memberElement.key) !== 'allOf'), cloneDeep(schemaElement.meta), cloneDeep(schemaElement.attributes));
         }
 
         // collect errors if allOf keyword contains anything else than Schema Object

package/es/resolver/apidom/reference/dereference/strategies/openapi-3-1-swagger-client/visitors/dereference.js

@@ -1,5 +1,5 @@
 /* eslint-disable camelcase */
-import { isObjectElement, isPrimitiveElement, isStringElement, visit, includesClasses } from '@swagger-api/apidom-core';
+import { isObjectElement, isPrimitiveElement, isStringElement, isMemberElement, visit, toValue, cloneShallow, cloneDeep } from '@swagger-api/apidom-core';
 import { isReferenceElementExternal, isReferenceLikeElement, isPathItemElementExternal, isBooleanJsonSchemaElement, ReferenceElement, PathItemElement, SchemaElement, getNodeType, keyMap } from '@swagger-api/apidom-ns-openapi-3-1';
 import { evaluate as jsonPointerEvaluate, uriToPointer } from '@swagger-api/apidom-json-pointer';
 import { url, MaximumDereferenceDepthError, File } from '@swagger-api/apidom-reference/configuration/empty';
@@ -31,53 +31,47 @@ const OpenApi3_1SwaggerClientDereferenceVisitor = OpenApi3_1DereferenceVisitor.c
     this.basePath = basePath;
   },
   methods: {
-    async ReferenceElement(referenceElement, key, parent, path, ancestors) {
+    async ReferenceElement(referencingElement, key, parent, path, ancestors) {
       try {
-        var _this$basePath, _referenceElement$$re, _referenceElement$des, _referenceElement$sum;
+        var _this$basePath;
         const [ancestorsLineage, directAncestors] = this.toAncestorLineage([...ancestors, parent]);
 
-        // skip already identified cycled Path Item Objects
-        if (includesClasses(['cycle'], referenceElement.$ref)) {
-          return false;
-        }
-
         // detect possible cycle in traversal and avoid it
-        if (ancestorsLineage.some(ancs => ancs.has(referenceElement))) {
-          // skip processing this schema and all it's child schemas
+        if (ancestorsLineage.includesCycle(referencingElement)) {
           return false;
         }
 
         // ignore resolving external Reference Objects
-        if (!this.options.resolve.external && isReferenceElementExternal(referenceElement)) {
+        if (!this.options.resolve.external && isReferenceElementExternal(referencingElement)) {
           return false;
         }
-        const reference = await this.toReference(referenceElement.$ref.toValue());
+        const reference = await this.toReference(toValue(referencingElement.$ref));
         const {
           uri: retrievalURI
         } = reference;
-        const $refBaseURI = url.resolve(retrievalURI, referenceElement.$ref.toValue());
-        this.indirections.push(referenceElement);
+        const $refBaseURI = url.resolve(retrievalURI, toValue(referencingElement.$ref));
+        this.indirections.push(referencingElement);
         const jsonPointer = uriToPointer($refBaseURI);
 
         // possibly non-semantic fragment
-        let fragment = jsonPointerEvaluate(jsonPointer, reference.value.result);
+        let referencedElement = jsonPointerEvaluate(jsonPointer, reference.value.result);
 
         // applying semantics to a fragment
-        if (isPrimitiveElement(fragment)) {
-          const referencedElementType = referenceElement.meta.get('referenced-element').toValue();
-          if (isReferenceLikeElement(fragment)) {
+        if (isPrimitiveElement(referencedElement)) {
+          const referencedElementType = toValue(referencingElement.meta.get('referenced-element'));
+          if (isReferenceLikeElement(referencedElement)) {
             // handling indirect references
-            fragment = ReferenceElement.refract(fragment);
-            fragment.setMetaProperty('referenced-element', referencedElementType);
+            referencedElement = ReferenceElement.refract(referencedElement);
+            referencedElement.setMetaProperty('referenced-element', referencedElementType);
           } else {
             // handling direct references
             const ElementClass = this.namespace.getElementClass(referencedElementType);
-            fragment = ElementClass.refract(fragment);
+            referencedElement = ElementClass.refract(referencedElement);
           }
         }
 
         // detect direct or indirect reference
-        if (this.indirections.includes(fragment)) {
+        if (this.indirections.includes(referencedElement)) {
           throw new Error('Recursive JSON Pointer detected');
         }
 
@@ -86,23 +80,21 @@ const OpenApi3_1SwaggerClientDereferenceVisitor = OpenApi3_1DereferenceVisitor.c
           throw new MaximumDereferenceDepthError(`Maximum dereference depth of "${this.options.dereference.maxDepth}" has been exceeded in file "${this.reference.uri}"`);
         }
         if (!this.useCircularStructures) {
-          const hasCycles = ancestorsLineage.some(ancs => ancs.has(fragment));
+          const hasCycles = ancestorsLineage.includes(referencedElement);
           if (hasCycles) {
             if (url.isHttpUrl(retrievalURI) || url.isFileSystemPath(retrievalURI)) {
               // make the referencing URL or file system path absolute
-              const cycledReferenceElement = new ReferenceElement({
+              return new ReferenceElement({
                 $ref: $refBaseURI
-              }, referenceElement.meta.clone(), referenceElement.attributes.clone());
-              cycledReferenceElement.get('$ref').classes.push('cycle');
-              return cycledReferenceElement;
+              }, cloneDeep(referencingElement.meta), cloneDeep(referencingElement.attributes));
             }
-            // skip processing this schema and all it's child schemas
+            // skip processing this reference
             return false;
           }
         }
 
         // append referencing schema to ancestors lineage
-        directAncestors.add(referenceElement);
+        directAncestors.add(referencingElement);
 
         // dive deep into the fragment
         const visitor = OpenApi3_1SwaggerClientDereferenceVisitor({
@@ -113,55 +105,78 @@ const OpenApi3_1SwaggerClientDereferenceVisitor = OpenApi3_1DereferenceVisitor.c
           ancestors: ancestorsLineage,
           allowMetaPatches: this.allowMetaPatches,
           useCircularStructures: this.useCircularStructures,
-          basePath: (_this$basePath = this.basePath) !== null && _this$basePath !== void 0 ? _this$basePath : [...toPath([...ancestors, parent, referenceElement]), '$ref']
+          basePath: (_this$basePath = this.basePath) !== null && _this$basePath !== void 0 ? _this$basePath : [...toPath([...ancestors, parent, referencingElement]), '$ref']
         });
-        fragment = await visitAsync(fragment, visitor, {
+        referencedElement = await visitAsync(referencedElement, visitor, {
           keyMap,
           nodeTypeGetter: getNodeType
         });
 
         // remove referencing schema from ancestors lineage
-        directAncestors.delete(referenceElement);
+        directAncestors.delete(referencingElement);
         this.indirections.pop();
-        fragment = fragment.clone();
-        fragment.setMetaProperty('ref-fields', {
-          $ref: (_referenceElement$$re = referenceElement.$ref) === null || _referenceElement$$re === void 0 ? void 0 : _referenceElement$$re.toValue(),
-          description: (_referenceElement$des = referenceElement.description) === null || _referenceElement$des === void 0 ? void 0 : _referenceElement$des.toValue(),
-          summary: (_referenceElement$sum = referenceElement.summary) === null || _referenceElement$sum === void 0 ? void 0 : _referenceElement$sum.toValue()
-        });
-        // annotate fragment with info about origin
-        fragment.setMetaProperty('ref-origin', reference.uri);
-
-        // override description and summary (outer has higher priority then inner)
-        const hasDescription = typeof referenceElement.description !== 'undefined';
-        const hasSummary = typeof referenceElement.summary !== 'undefined';
-        if (hasDescription && 'description' in fragment) {
-          fragment.description = referenceElement.description;
-        }
-        if (hasSummary && 'summary' in fragment) {
-          fragment.summary = referenceElement.summary;
-        }
+        const mergeAndAnnotateReferencedElement = refedElement => {
+          const copy = cloneShallow(refedElement);
+
+          // annotate fragment with info about original Reference element
+          copy.setMetaProperty('ref-fields', {
+            $ref: toValue(referencingElement.$ref),
+            // @ts-ignore
+            description: toValue(referencingElement.description),
+            // @ts-ignore
+            summary: toValue(referencingElement.summary)
+          });
+          // annotate fragment with info about origin
+          copy.setMetaProperty('ref-origin', reference.uri);
+
+          // override description and summary (outer has higher priority then inner)
+          if (isObjectElement(refedElement)) {
+            if (referencingElement.hasKey('description') && 'description' in refedElement) {
+              // @ts-ignore
+              copy.remove('description');
+              // @ts-ignore
+              copy.set('description', referencingElement.get('description'));
+            }
+            if (referencingElement.hasKey('summary') && 'summary' in refedElement) {
+              // @ts-ignore
+              copy.remove('summary');
+              // @ts-ignore
+              copy.set('summary', referencingElement.get('summary'));
+            }
+          }
 
-        // apply meta patches
-        if (this.allowMetaPatches && isObjectElement(fragment)) {
-          const objectFragment = fragment;
-          // apply meta patch only when not already applied
-          if (typeof objectFragment.get('$$ref') === 'undefined') {
-            const baseURI = url.resolve(retrievalURI, $refBaseURI);
-            objectFragment.set('$$ref', baseURI);
+          // apply meta patches
+          if (this.allowMetaPatches && isObjectElement(copy)) {
+            // apply meta patch only when not already applied
+            if (!copy.hasKey('$$ref')) {
+              const baseURI = url.resolve(retrievalURI, $refBaseURI);
+              copy.set('$$ref', baseURI);
+            }
+          }
+          return copy;
+        };
+
+        // attempting to create cycle
+        if (ancestorsLineage.includes(referencedElement)) {
+          if (isMemberElement(parent)) {
+            parent.value = mergeAndAnnotateReferencedElement(referencedElement); // eslint-disable-line no-param-reassign
+          } else if (Array.isArray(parent)) {
+            parent[key] = mergeAndAnnotateReferencedElement(referencedElement); // eslint-disable-line no-param-reassign
           }
+
+          return false;
         }
 
         // transclude the element for a fragment
-        return fragment;
+        return mergeAndAnnotateReferencedElement(referencedElement);
       } catch (error) {
         var _this$basePath2, _this$options$derefer, _this$options$derefer2;
         const rootCause = getRootCause(error);
         const wrappedError = wrapError(rootCause, {
           baseDoc: this.reference.uri,
-          $ref: referenceElement.$ref.toValue(),
-          pointer: uriToPointer(referenceElement.$ref.toValue()),
-          fullPath: (_this$basePath2 = this.basePath) !== null && _this$basePath2 !== void 0 ? _this$basePath2 : [...toPath([...ancestors, parent, referenceElement]), '$ref']
+          $ref: toValue(referencingElement.$ref),
+          pointer: uriToPointer(toValue(referencingElement.$ref)),
+          fullPath: (_this$basePath2 = this.basePath) !== null && _this$basePath2 !== void 0 ? _this$basePath2 : [...toPath([...ancestors, parent, referencingElement]), '$ref']
         });
         (_this$options$derefer = this.options.dereference.dereferenceOpts) === null || _this$options$derefer === void 0 || (_this$options$derefer = _this$options$derefer.errors) === null || _this$options$derefer === void 0 || (_this$options$derefer2 = _this$options$derefer.push) === null || _this$options$derefer2 === void 0 || _this$options$derefer2.call(_this$options$derefer, wrappedError);
         return undefined;
@@ -169,7 +184,7 @@ const OpenApi3_1SwaggerClientDereferenceVisitor = OpenApi3_1DereferenceVisitor.c
     },
     async PathItemElement(pathItemElement, key, parent, path, ancestors) {
       try {
-        var _this$basePath3, _pathItemElement$$ref;
+        var _this$basePath3;
         const [ancestorsLineage, directAncestors] = this.toAncestorLineage([...ancestors, parent]);
 
         // ignore PathItemElement without $ref field
@@ -177,14 +192,8 @@ const OpenApi3_1SwaggerClientDereferenceVisitor = OpenApi3_1DereferenceVisitor.c
           return undefined;
         }
 
-        // skip already identified cycled Path Item Objects
-        if (includesClasses(['cycle'], pathItemElement.$ref)) {
-          return false;
-        }
-
         // detect possible cycle in traversal and avoid it
-        if (ancestorsLineage.some(ancs => ancs.has(pathItemElement))) {
-          // skip processing this schema and all it's child schemas
+        if (ancestorsLineage.includesCycle(pathItemElement)) {
           return false;
         }
 
@@ -192,11 +201,11 @@ const OpenApi3_1SwaggerClientDereferenceVisitor = OpenApi3_1DereferenceVisitor.c
         if (!this.options.resolve.external && isPathItemElementExternal(pathItemElement)) {
           return undefined;
         }
-        const reference = await this.toReference(pathItemElement.$ref.toValue());
+        const reference = await this.toReference(toValue(pathItemElement.$ref));
         const {
           uri: retrievalURI
         } = reference;
-        const $refBaseURI = url.resolve(retrievalURI, pathItemElement.$ref.toValue());
+        const $refBaseURI = url.resolve(retrievalURI, toValue(pathItemElement.$ref));
         this.indirections.push(pathItemElement);
         const jsonPointer = uriToPointer($refBaseURI);
 
@@ -218,17 +227,15 @@ const OpenApi3_1SwaggerClientDereferenceVisitor = OpenApi3_1DereferenceVisitor.c
           throw new MaximumDereferenceDepthError(`Maximum dereference depth of "${this.options.dereference.maxDepth}" has been exceeded in file "${this.reference.uri}"`);
         }
         if (!this.useCircularStructures) {
-          const hasCycles = ancestorsLineage.some(ancs => ancs.has(referencedElement));
+          const hasCycles = ancestorsLineage.includes(referencedElement);
           if (hasCycles) {
             if (url.isHttpUrl(retrievalURI) || url.isFileSystemPath(retrievalURI)) {
               // make the referencing URL or file system path absolute
-              const cycledPathItemElement = new PathItemElement({
+              return new PathItemElement({
                 $ref: $refBaseURI
-              }, pathItemElement.meta.clone(), pathItemElement.attributes.clone());
-              cycledPathItemElement.get('$ref').classes.push('cycle');
-              return cycledPathItemElement;
+              }, cloneDeep(pathItemElement.meta), cloneDeep(pathItemElement.attributes));
             }
-            // skip processing this schema and all it's child schemas
+            // skip processing this path item and all it's child elements
             return false;
           }
         }
@@ -255,41 +262,54 @@ const OpenApi3_1SwaggerClientDereferenceVisitor = OpenApi3_1DereferenceVisitor.c
         // remove referencing schema from ancestors lineage
         directAncestors.delete(pathItemElement);
         this.indirections.pop();
+        const mergeAndAnnotateReferencedElement = refedElement => {
+          // merge fields from referenced Path Item with referencing one
+          const mergedElement = new PathItemElement([...refedElement.content], cloneDeep(refedElement.meta), cloneDeep(refedElement.attributes));
+          // existing keywords from referencing PathItemElement overrides ones from referenced element
+          pathItemElement.forEach((value, keyElement, item) => {
+            mergedElement.remove(toValue(keyElement));
+            mergedElement.content.push(item);
+          });
+          mergedElement.remove('$ref');
 
-        // merge fields from referenced Path Item with referencing one
-        const mergedPathItemElement = new PathItemElement([...referencedElement.content], referencedElement.meta.clone(), referencedElement.attributes.clone());
-        // existing keywords from referencing PathItemElement overrides ones from referenced element
-        pathItemElement.forEach((valueElement, keyElement, item) => {
-          mergedPathItemElement.remove(keyElement.toValue());
-          mergedPathItemElement.content.push(item);
-        });
-        mergedPathItemElement.remove('$ref');
+          // annotate referenced element with info about original referencing element
+          mergedElement.setMetaProperty('ref-fields', {
+            $ref: toValue(pathItemElement.$ref)
+          });
+          // annotate referenced element with info about origin
+          mergedElement.setMetaProperty('ref-origin', reference.uri);
 
-        // annotate referenced element with info about original referencing element
-        mergedPathItemElement.setMetaProperty('ref-fields', {
-          $ref: (_pathItemElement$$ref = pathItemElement.$ref) === null || _pathItemElement$$ref === void 0 ? void 0 : _pathItemElement$$ref.toValue()
-        });
-        // annotate referenced element with info about origin
-        mergedPathItemElement.setMetaProperty('ref-origin', reference.uri);
-
-        // apply meta patches
-        if (this.allowMetaPatches) {
-          // apply meta patch only when not already applied
-          if (typeof mergedPathItemElement.get('$$ref') === 'undefined') {
-            const baseURI = url.resolve(retrievalURI, $refBaseURI);
-            mergedPathItemElement.set('$$ref', baseURI);
+          // apply meta patches
+          if (this.allowMetaPatches) {
+            // apply meta patch only when not already applied
+            if (typeof mergedElement.get('$$ref') === 'undefined') {
+              const baseURI = url.resolve(retrievalURI, $refBaseURI);
+              mergedElement.set('$$ref', baseURI);
+            }
+          }
+          return mergedElement;
+        };
+
+        // attempting to create cycle
+        if (ancestorsLineage.includes(referencedElement)) {
+          if (isMemberElement(parent)) {
+            parent.value = mergeAndAnnotateReferencedElement(referencedElement); // eslint-disable-line no-param-reassign
+          } else if (Array.isArray(parent)) {
+            parent[key] = mergeAndAnnotateReferencedElement(referencedElement); // eslint-disable-line no-param-reassign
           }
+
+          return false;
         }
 
         // transclude referencing element with merged referenced element
-        return mergedPathItemElement;
+        return mergeAndAnnotateReferencedElement(referencedElement);
       } catch (error) {
         var _this$basePath4, _this$options$derefer3, _this$options$derefer4;
         const rootCause = getRootCause(error);
         const wrappedError = wrapError(rootCause, {
           baseDoc: this.reference.uri,
-          $ref: pathItemElement.$ref.toValue(),
-          pointer: uriToPointer(pathItemElement.$ref.toValue()),
+          $ref: toValue(pathItemElement.$ref),
+          pointer: uriToPointer(toValue(pathItemElement.$ref)),
           fullPath: (_this$basePath4 = this.basePath) !== null && _this$basePath4 !== void 0 ? _this$basePath4 : [...toPath([...ancestors, parent, pathItemElement]), '$ref']
         });
         (_this$options$derefer3 = this.options.dereference.dereferenceOpts) === null || _this$options$derefer3 === void 0 || (_this$options$derefer3 = _this$options$derefer3.errors) === null || _this$options$derefer3 === void 0 || (_this$options$derefer4 = _this$options$derefer3.push) === null || _this$options$derefer4 === void 0 || _this$options$derefer4.call(_this$options$derefer3, wrappedError);
@@ -298,7 +318,7 @@ const OpenApi3_1SwaggerClientDereferenceVisitor = OpenApi3_1DereferenceVisitor.c
     },
     async SchemaElement(referencingElement, key, parent, path, ancestors) {
       try {
-        var _this$basePath5, _referencingElement$$2;
+        var _this$basePath5;
         const [ancestorsLineage, directAncestors] = this.toAncestorLineage([...ancestors, parent]);
 
         // skip current referencing schema as $ref keyword was not defined
@@ -307,14 +327,8 @@ const OpenApi3_1SwaggerClientDereferenceVisitor = OpenApi3_1DereferenceVisitor.c
           return undefined;
         }
 
-        // skip already identified cycled schemas
-        if (includesClasses(['cycle'], referencingElement.$ref)) {
-          return false;
-        }
-
         // detect possible cycle in traversal and avoid it
-        if (ancestorsLineage.some(ancs => ancs.has(referencingElement))) {
-          // skip processing this schema and all it's child schemas
+        if (ancestorsLineage.includesCycle(referencingElement)) {
           return false;
         }
 
@@ -394,11 +408,9 @@ const OpenApi3_1SwaggerClientDereferenceVisitor = OpenApi3_1DereferenceVisitor.c
             if (url.isHttpUrl(retrievalURI) || url.isFileSystemPath(retrievalURI)) {
               // make the referencing URL or file system path absolute
               const baseURI = url.resolve(retrievalURI, $refBaseURI);
-              const cycledSchemaElement = new SchemaElement({
+              return new SchemaElement({
                 $ref: baseURI
-              }, referencingElement.meta.clone(), referencingElement.attributes.clone());
-              cycledSchemaElement.get('$ref').classes.push('cycle');
-              return cycledSchemaElement;
+              }, cloneDeep(referencingElement.meta), cloneDeep(referencingElement.attributes));
             }
             // skip processing this schema and all it's child schemas
             return false;
@@ -428,51 +440,61 @@ const OpenApi3_1SwaggerClientDereferenceVisitor = OpenApi3_1DereferenceVisitor.c
         directAncestors.delete(referencingElement);
         this.indirections.pop();
         if (isBooleanJsonSchemaElement(referencedElement)) {
-          var _referencingElement$$;
-          // Boolean JSON Schema
-          const jsonSchemaBooleanElement = referencedElement.clone();
+          const booleanJsonSchemaElement = cloneDeep(referencedElement);
           // annotate referenced element with info about original referencing element
-          jsonSchemaBooleanElement.setMetaProperty('ref-fields', {
-            $ref: (_referencingElement$$ = referencingElement.$ref) === null || _referencingElement$$ === void 0 ? void 0 : _referencingElement$$.toValue()
+          booleanJsonSchemaElement.setMetaProperty('ref-fields', {
+            $ref: toValue(referencingElement.$ref)
           });
           // annotate referenced element with info about origin
-          jsonSchemaBooleanElement.setMetaProperty('ref-origin', retrievalURI);
-          return jsonSchemaBooleanElement;
+          booleanJsonSchemaElement.setMetaProperty('ref-origin', reference.uri);
+          return booleanJsonSchemaElement;
         }
+        const mergeAndAnnotateReferencedElement = refedElement => {
+          // Schema Object - merge keywords from referenced schema with referencing schema
+          const mergedElement = new SchemaElement([...refedElement.content], cloneDeep(refedElement.meta), cloneDeep(refedElement.attributes));
+          // existing keywords from referencing schema overrides ones from referenced schema
+          referencingElement.forEach((value, keyElement, item) => {
+            mergedElement.remove(toValue(keyElement));
+            mergedElement.content.push(item);
+          });
+          mergedElement.remove('$ref');
+          // annotate referenced element with info about original referencing element
+          mergedElement.setMetaProperty('ref-fields', {
+            $ref: toValue(referencingElement.$ref)
+          });
+          // annotate fragment with info about origin
+          mergedElement.setMetaProperty('ref-origin', reference.uri);
 
-        // Schema Object - merge keywords from referenced schema with referencing schema
-        const mergedSchemaElement = new SchemaElement([...referencedElement.content], referencedElement.meta.clone(), referencedElement.attributes.clone());
-        // existing keywords from referencing schema overrides ones from referenced schema
-        referencingElement.forEach((memberValue, memberKey, member) => {
-          mergedSchemaElement.remove(memberKey.toValue());
-          mergedSchemaElement.content.push(member);
-        });
-        mergedSchemaElement.remove('$ref');
-
-        // annotate referenced element with info about original referencing element
-        mergedSchemaElement.setMetaProperty('ref-fields', {
-          $ref: (_referencingElement$$2 = referencingElement.$ref) === null || _referencingElement$$2 === void 0 ? void 0 : _referencingElement$$2.toValue()
-        });
-        // annotate fragment with info about origin
-        mergedSchemaElement.setMetaProperty('ref-origin', retrievalURI);
-
-        // allowMetaPatches option processing
-        if (this.allowMetaPatches) {
-          // apply meta patch only when not already applied
-          if (typeof mergedSchemaElement.get('$$ref') === 'undefined') {
-            const baseURI = url.resolve(retrievalURI, $refBaseURI);
-            mergedSchemaElement.set('$$ref', baseURI);
+          // allowMetaPatches option processing
+          if (this.allowMetaPatches) {
+            // apply meta patch only when not already applied
+            if (typeof mergedElement.get('$$ref') === 'undefined') {
+              const baseURI = url.resolve(retrievalURI, $refBaseURI);
+              mergedElement.set('$$ref', baseURI);
+            }
           }
+          return mergedElement;
+        };
+
+        // attempting to create cycle
+        if (ancestorsLineage.includes(referencedElement)) {
+          if (isMemberElement(parent)) {
+            parent.value = mergeAndAnnotateReferencedElement(referencedElement); // eslint-disable-line no-param-reassign
+          } else if (Array.isArray(parent)) {
+            parent[key] = mergeAndAnnotateReferencedElement(referencedElement); // eslint-disable-line no-param-reassign
+          }
+
+          return false;
         }
 
         // transclude referencing element with merged referenced element
-        return mergedSchemaElement;
+        return mergeAndAnnotateReferencedElement(referencedElement);
       } catch (error) {
         var _this$basePath6, _this$options$derefer5, _this$options$derefer6;
         const rootCause = getRootCause(error);
         const wrappedError = new SchemaRefError(`Could not resolve reference: ${rootCause.message}`, {
           baseDoc: this.reference.uri,
-          $ref: referencingElement.$ref.toValue(),
+          $ref: toValue(referencingElement.$ref),
           fullPath: (_this$basePath6 = this.basePath) !== null && _this$basePath6 !== void 0 ? _this$basePath6 : [...toPath([...ancestors, parent, referencingElement]), '$ref']
         }, rootCause);
         (_this$options$derefer5 = this.options.dereference.dereferenceOpts) === null || _this$options$derefer5 === void 0 || (_this$options$derefer5 = _this$options$derefer5.errors) === null || _this$options$derefer5 === void 0 || (_this$options$derefer6 = _this$options$derefer5.push) === null || _this$options$derefer6 === void 0 || _this$options$derefer6.call(_this$options$derefer5, wrappedError);
@@ -491,11 +513,11 @@ const OpenApi3_1SwaggerClientDereferenceVisitor = OpenApi3_1DereferenceVisitor.c
       try {
         return await OpenApi3_1DereferenceVisitor.compose.methods.ExampleElement.call(this, exampleElement, key, parent, path, ancestors);
       } catch (error) {
-        var _exampleElement$exter, _this$basePath7, _this$options$derefer7, _this$options$derefer8;
+        var _this$basePath7, _this$options$derefer7, _this$options$derefer8;
         const rootCause = getRootCause(error);
         const wrappedError = wrapError(rootCause, {
           baseDoc: this.reference.uri,
-          externalValue: (_exampleElement$exter = exampleElement.externalValue) === null || _exampleElement$exter === void 0 ? void 0 : _exampleElement$exter.toValue(),
+          externalValue: toValue(exampleElement.externalValue),
           fullPath: (_this$basePath7 = this.basePath) !== null && _this$basePath7 !== void 0 ? _this$basePath7 : [...toPath([...ancestors, parent, exampleElement]), 'externalValue']
         });
         (_this$options$derefer7 = this.options.dereference.dereferenceOpts) === null || _this$options$derefer7 === void 0 || (_this$options$derefer7 = _this$options$derefer7.errors) === null || _this$options$derefer7 === void 0 || (_this$options$derefer8 = _this$options$derefer7.push) === null || _this$options$derefer8 === void 0 || _this$options$derefer8.call(_this$options$derefer7, wrappedError);

package/lib/constants.js

@@ -2,7 +2,5 @@
 
 exports.__esModule = true;
 exports.DEFAULT_BASE_URL = exports.ACCEPT_HEADER_VALUE_FOR_DOCUMENTS = void 0;
-const ACCEPT_HEADER_VALUE_FOR_DOCUMENTS = 'application/json, application/yaml';
-exports.ACCEPT_HEADER_VALUE_FOR_DOCUMENTS = ACCEPT_HEADER_VALUE_FOR_DOCUMENTS;
-const DEFAULT_BASE_URL = 'https://swagger.io';
-exports.DEFAULT_BASE_URL = DEFAULT_BASE_URL;
+const ACCEPT_HEADER_VALUE_FOR_DOCUMENTS = exports.ACCEPT_HEADER_VALUE_FOR_DOCUMENTS = 'application/json, application/yaml';
+const DEFAULT_BASE_URL = exports.DEFAULT_BASE_URL = 'https://swagger.io';

package/lib/execute/index.js

@@ -72,13 +72,12 @@ const deduplicateParameters = parameters => {
 };
 
 // For stubbing in tests
-const self = {
+const self = exports.self = {
   buildRequest
 };
 
 // Execute request, with the given operationId and parameters
 // pathName/method or operationId is optional
-exports.self = self;
 function execute(_ref) {
   let {
     http: userHttp,

package/lib/execute/swagger2/parameter-builders.js

@@ -4,14 +4,13 @@ exports.__esModule = true;
 exports.default = void 0;
 // These functions will update the request.
 // They'll be given {req, value, paramter, spec, operation}.
-var _default = {
+var _default = exports.default = {
   body: bodyBuilder,
   header: headerBuilder,
   query: queryBuilder,
   path: pathBuilder,
   formData: formDataBuilder
 }; // Add the body to the request
-exports.default = _default;
 function bodyBuilder(_ref) {
   let {
     req,

package/lib/helpers/btoa.browser.js

@@ -19,5 +19,4 @@ const globalObject = (() => {
 const {
   btoa
 } = globalObject;
-var _default = btoa;
-exports.default = _default;
+var _default = exports.default = btoa;

package/lib/helpers/btoa.node.js

@@ -12,5 +12,4 @@ const btoa = val => {
   }
   return buffer.toString('base64');
 };
-var _default = btoa;
-exports.default = _default;
+var _default = exports.default = btoa;

package/lib/helpers/fetch-ponyfill-undici.node.js

@@ -10,5 +10,4 @@ exports.Headers = _undici.Headers;
 exports.Request = _undici.Request;
 exports.FormData = _undici.FormData;
 exports.File = _undici.File;
-const BlobU = typeof _undici.fetch === 'undefined' ? undefined : _buffer.Blob;
-exports.Blob = BlobU;
+const BlobU = exports.Blob = typeof _undici.fetch === 'undefined' ? undefined : _buffer.Blob;

package/lib/helpers/replace-special-chars-with-underscore.js

@@ -3,5 +3,4 @@
 exports.__esModule = true;
 exports.default = void 0;
 const replaceSpecialCharsWithUnderscore = operationId => operationId.replace(/\W/gi, '_');
-var _default = replaceSpecialCharsWithUnderscore;
-exports.default = _default;
+var _default = exports.default = replaceSpecialCharsWithUnderscore;

package/lib/http/index.js

@@ -16,14 +16,13 @@ var _jsYaml = _interopRequireDefault(require("js-yaml"));
 require("../helpers/fetch-polyfill.node.js");
 var _styleSerializer = require("../execute/oas3/style-serializer.js");
 // For testing
-const self = {
+const self = exports.self = {
   serializeRes,
   mergeInQueryOrForm
 };
 
 // Handles fetch-like syntax and the case where there is only one object passed-in
 // (which will have the URL as a property). Also serializes the response.
-exports.self = self;
 async function http(url, request) {
   if (request === void 0) {
     request = {};

package/lib/index.js

@@ -155,6 +155,5 @@ const {
   helpers
 } = Swagger;
 exports.helpers = helpers;
-var _default = Swagger;
-/* eslint-enable camelcase */
-exports.default = _default;
+var _default = exports.default = Swagger;
+/* eslint-enable camelcase */