@swagger-api/apidom-ns-openapi-3-0 0.68.1

package/es/refractor/visitors/SpecificationVisitor.js

@@ -0,0 +1,77 @@
+import _defineProperty from "@babel/runtime-corejs3/helpers/esm/defineProperty";
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+import stampit from 'stampit';
+import { pathSatisfies, path, pick, pipe, keys } from 'ramda';
+import { isFunction, isUndefined } from 'ramda-adjunct';
+import { visit } from '@swagger-api/apidom-core';
+import Visitor from "./Visitor.js";
+import { keyMap, getNodeType } from "../../traversal/visitor.js";
+/**
+ * This is a base Type for every visitor that does
+ * internal look-ups to retrieve other child visitors.
+ */
+const SpecificationVisitor = stampit(Visitor, {
+  props: {
+    passingOptionsNames: ['specObj', 'openApiGenericElement', 'openApiSemanticElement'],
+    specObj: null,
+    openApiGenericElement: null,
+    openApiSemanticElement: null
+  },
+  init({
+    // @ts-ignore
+    specObj = this.specObj,
+    // @ts-ignore
+    openApiGenericElement = this.openApiGenericElement,
+    // @ts-ignore
+    openApiSemanticElement = this.openApiSemanticElement
+  }) {
+    this.specObj = specObj;
+    this.openApiGenericElement = openApiGenericElement;
+    this.openApiSemanticElement = openApiSemanticElement;
+  },
+  methods: {
+    retrievePassingOptions() {
+      return pick(this.passingOptionsNames, this);
+    },
+    retrieveFixedFields(specPath) {
+      return pipe(path(['visitors', ...specPath, 'fixedFields']), keys)(this.specObj);
+    },
+    retrieveVisitor(specPath) {
+      if (pathSatisfies(isFunction, ['visitors', ...specPath], this.specObj)) {
+        return path(['visitors', ...specPath], this.specObj);
+      }
+      return path(['visitors', ...specPath, '$visitor'], this.specObj);
+    },
+    retrieveVisitorInstance(specPath, options = {}) {
+      const passingOpts = this.retrievePassingOptions();
+      return this.retrieveVisitor(specPath)(_objectSpread(_objectSpread({}, passingOpts), options));
+    },
+    toRefractedElement(specPath, element, options = {}) {
+      /**
+       * This is `Visitor shortcut`: mechanism for short circuiting the traversal and replacing
+       * it by basic node cloning.
+       *
+       * Visiting the element is equivalent to cloning it  if the prototype of a visitor
+       * is the same as the prototype of FallbackVisitor. If that's the case, we can avoid
+       * bootstrapping the traversal cycle for fields that don't require any special visiting.
+       */
+      const visitor = this.retrieveVisitorInstance(specPath, options);
+      const visitorPrototype = Object.getPrototypeOf(visitor);
+      if (isUndefined(this.fallbackVisitorPrototype)) {
+        this.fallbackVisitorPrototype = Object.getPrototypeOf(this.retrieveVisitorInstance(['value']));
+      }
+      if (this.fallbackVisitorPrototype === visitorPrototype) {
+        return element.clone();
+      }
+
+      // standard processing continues
+      visit(element, visitor, _objectSpread({
+        keyMap,
+        nodeTypeGetter: getNodeType
+      }, options));
+      return visitor.element;
+    }
+  }
+});
+export default SpecificationVisitor;

package/es/refractor/visitors/Visitor.js

@@ -0,0 +1,17 @@
+import stampit from 'stampit';
+import { hasElementSourceMap } from '@swagger-api/apidom-core';
+const Visitor = stampit({
+  props: {
+    element: null
+  },
+  // @ts-ignore
+  methods: {
+    copyMetaAndAttributes(from, to) {
+      // copy sourcemaps
+      if (hasElementSourceMap(from)) {
+        to.meta.set('sourceMap', from.meta.get('sourceMap'));
+      }
+    }
+  }
+});
+export default Visitor;

package/es/refractor/visitors/generics/AlternatingVisitor.js

@@ -0,0 +1,22 @@
+import stampit from 'stampit';
+import { ifElse, always } from 'ramda';
+import { dispatch, stubUndefined } from 'ramda-adjunct';
+import { BREAK } from '@swagger-api/apidom-core';
+import SpecificationVisitor from "../SpecificationVisitor.js";
+const AlternatingVisitor = stampit(SpecificationVisitor, {
+  props: {
+    alternator: []
+  },
+  methods: {
+    enter(element) {
+      const functions = this.alternator.map(({
+        predicate,
+        specPath
+      }) => ifElse(predicate, always(specPath), stubUndefined));
+      const specPath = dispatch(functions)(element);
+      this.element = this.toRefractedElement(specPath, element);
+      return BREAK;
+    }
+  }
+});
+export default AlternatingVisitor;

package/es/refractor/visitors/generics/FixedFieldsVisitor.js

@@ -0,0 +1,51 @@
+import stampit from 'stampit';
+import { noop } from 'ramda-adjunct';
+import { isStringElement, MemberElement, BREAK } from '@swagger-api/apidom-core';
+import SpecificationVisitor from "../SpecificationVisitor.js";
+import { isOpenApiExtension } from "../../predicates.js";
+const FixedFieldsVisitor = stampit(SpecificationVisitor, {
+  props: {
+    specPath: noop,
+    ignoredFields: [],
+    canSupportSpecificationExtensions: true,
+    specificationExtensionPredicate: isOpenApiExtension
+  },
+  init({
+    // @ts-ignore
+    specPath = this.specPath,
+    // @ts-ignore
+    ignoredFields = this.ignoredFields,
+    // @ts-ignore
+    canSupportSpecificationExtensions = this.canSupportSpecificationExtensions,
+    // @ts-ignore
+    specificationExtensionPredicate = this.specificationExtensionPredicate
+  } = {}) {
+    this.specPath = specPath;
+    this.ignoredFields = ignoredFields;
+    this.canSupportSpecificationExtensions = canSupportSpecificationExtensions;
+    this.specificationExtensionPredicate = specificationExtensionPredicate;
+  },
+  methods: {
+    ObjectElement(objectElement) {
+      const specPath = this.specPath(objectElement);
+      const fields = this.retrieveFixedFields(specPath);
+      objectElement.forEach((value, key, memberElement) => {
+        if (isStringElement(key) && fields.includes(key.toValue()) && !this.ignoredFields.includes(key.toValue())) {
+          const fixedFieldElement = this.toRefractedElement([...specPath, 'fixedFields', key.toValue()], value);
+          const newMemberElement = new MemberElement(key.clone(), fixedFieldElement);
+          this.copyMetaAndAttributes(memberElement, newMemberElement);
+          newMemberElement.classes.push('fixed-field');
+          this.element.content.push(newMemberElement);
+        } else if (this.canSupportSpecificationExtensions && this.specificationExtensionPredicate(memberElement)) {
+          const extensionElement = this.toRefractedElement(['document', 'extension'], memberElement);
+          this.element.content.push(extensionElement);
+        } else if (!this.ignoredFields.includes(key.toValue())) {
+          this.element.content.push(memberElement.clone());
+        }
+      });
+      this.copyMetaAndAttributes(objectElement, this.element);
+      return BREAK;
+    }
+  }
+});
+export default FixedFieldsVisitor;

package/es/refractor/visitors/generics/MapVisitor.js

@@ -0,0 +1,9 @@
+import stampit from 'stampit';
+import { isNonEmptyString } from 'ramda-adjunct';
+import PatternedFieldsVisitor from "./PatternedFieldsVisitor.js";
+const MapVisitor = stampit(PatternedFieldsVisitor, {
+  props: {
+    fieldPatternPredicate: isNonEmptyString
+  }
+});
+export default MapVisitor;

package/es/refractor/visitors/generics/MixedFieldsVisitor.js

@@ -0,0 +1,37 @@
+import stampit from 'stampit';
+import { difference } from 'ramda';
+import { noop } from 'ramda-adjunct';
+import { BREAK } from '@swagger-api/apidom-core';
+import FixedFieldsVisitor from "./FixedFieldsVisitor.js";
+import PatternedFieldsVisitor from "./PatternedFieldsVisitor.js";
+const MixedFieldsVisitor = stampit(FixedFieldsVisitor, PatternedFieldsVisitor, {
+  props: {
+    specPathFixedFields: noop,
+    specPathPatternedFields: noop
+  },
+  methods: {
+    ObjectElement(objectElement) {
+      const {
+        specPath,
+        ignoredFields
+      } = this;
+      try {
+        this.specPath = this.specPathFixedFields;
+        const fixedFields = this.retrieveFixedFields(this.specPath(objectElement));
+        // let FixedFieldsVisitor only process fixed fields and leave rest to PatternedFieldsVisitor
+        this.ignoredFields = [...ignoredFields, ...difference(objectElement.keys(), fixedFields)];
+        // @ts-ignore
+        FixedFieldsVisitor.compose.methods.ObjectElement.call(this, objectElement);
+        this.specPath = this.specPathPatternedFields;
+        this.ignoredFields = fixedFields;
+        // @ts-ignore
+        PatternedFieldsVisitor.compose.methods.ObjectElement.call(this, objectElement);
+      } catch (e) {
+        this.specPath = specPath;
+        throw e;
+      }
+      return BREAK;
+    }
+  }
+});
+export default MixedFieldsVisitor;

package/es/refractor/visitors/generics/PatternedFieldsVisitor.js

@@ -0,0 +1,53 @@
+import stampit from 'stampit';
+import { F as stubFalse } from 'ramda';
+import { noop } from 'ramda-adjunct';
+import { MemberElement, BREAK } from '@swagger-api/apidom-core';
+import SpecificationVisitor from "../SpecificationVisitor.js";
+import { isOpenApiExtension } from "../../predicates.js";
+const PatternedFieldsJsonObjectVisitor = stampit(SpecificationVisitor, {
+  props: {
+    fieldPatternPredicate: stubFalse,
+    specPath: noop,
+    ignoredFields: [],
+    canSupportSpecificationExtensions: false,
+    specificationExtensionPredicate: isOpenApiExtension
+  },
+  init({
+    // @ts-ignore
+    specPath = this.specPath,
+    // @ts-ignore
+    ignoredFields = this.ignoredFields,
+    // @ts-ignore
+    canSupportSpecificationExtensions = this.canSupportSpecificationExtensions,
+    // @ts-ignore
+    specificationExtensionPredicate = this.specificationExtensionPredicate
+  } = {}) {
+    this.specPath = specPath;
+    this.ignoredFields = ignoredFields;
+    this.canSupportSpecificationExtensions = canSupportSpecificationExtensions;
+    this.specificationExtensionPredicate = specificationExtensionPredicate;
+  },
+  methods: {
+    ObjectElement(objectElement) {
+      // @ts-ignore
+      objectElement.forEach((value, key, memberElement) => {
+        if (this.canSupportSpecificationExtensions && this.specificationExtensionPredicate(memberElement)) {
+          const extensionElement = this.toRefractedElement(['document', 'extension'], memberElement);
+          this.element.content.push(extensionElement);
+        } else if (!this.ignoredFields.includes(key.toValue()) && this.fieldPatternPredicate(key.toValue())) {
+          const specPath = this.specPath(value);
+          const patternedFieldElement = this.toRefractedElement(specPath, value);
+          const newMemberElement = new MemberElement(key.clone(), patternedFieldElement);
+          this.copyMetaAndAttributes(memberElement, newMemberElement);
+          newMemberElement.classes.push('patterned-field');
+          this.element.content.push(newMemberElement);
+        } else if (!this.ignoredFields.includes(key.toValue())) {
+          this.element.content.push(memberElement.clone());
+        }
+      });
+      this.copyMetaAndAttributes(objectElement, this.element);
+      return BREAK;
+    }
+  }
+});
+export default PatternedFieldsJsonObjectVisitor;

package/es/refractor/visitors/open-api-3-0/ContentVisitor.js

@@ -0,0 +1,15 @@
+import stampit from 'stampit';
+import { always } from 'ramda';
+import { ObjectElement } from '@swagger-api/apidom-core';
+import MapVisitor from "../generics/MapVisitor.js";
+import FallbackVisitor from "../FallbackVisitor.js";
+const ContentVisitor = stampit(MapVisitor, FallbackVisitor, {
+  props: {
+    specPath: always(['document', 'objects', 'MediaType'])
+  },
+  init() {
+    this.element = new ObjectElement();
+    this.element.classes.push('content');
+  }
+});
+export default ContentVisitor;

package/es/refractor/visitors/open-api-3-0/ExamplesVisitor.js

@@ -0,0 +1,27 @@
+import stampit from 'stampit';
+import { ObjectElement } from '@swagger-api/apidom-core';
+import MapVisitor from "../generics/MapVisitor.js";
+import FallbackVisitor from "../FallbackVisitor.js";
+import { isReferenceLikeElement } from "../../predicates.js";
+import { isReferenceElement } from "../../../predicates.js";
+const ExamplesVisitor = stampit(MapVisitor, FallbackVisitor, {
+  props: {
+    specPath: element => isReferenceLikeElement(element) ? ['document', 'objects', 'Reference'] : ['document', 'objects', 'Example'],
+    canSupportSpecificationExtensions: true
+  },
+  init() {
+    this.element = new ObjectElement();
+    this.element.classes.push('examples');
+  },
+  methods: {
+    ObjectElement(objectElement) {
+      // @ts-ignore
+      const result = MapVisitor.compose.methods.ObjectElement.call(this, objectElement);
+      this.element.filter(isReferenceElement).forEach(referenceElement => {
+        referenceElement.setMetaProperty('referenced-element', 'example');
+      });
+      return result;
+    }
+  }
+});
+export default ExamplesVisitor;

package/es/refractor/visitors/open-api-3-0/OpenapiVisitor.js

@@ -0,0 +1,16 @@
+import stampit from 'stampit';
+import { BREAK } from '@swagger-api/apidom-core';
+import FallbackVisitor from "../FallbackVisitor.js";
+import SpecificationVisitor from "../SpecificationVisitor.js";
+import OpenapiElement from "../../../elements/Openapi.js";
+const OpenapiVisitor = stampit(SpecificationVisitor, FallbackVisitor, {
+  methods: {
+    StringElement(stringElement) {
+      const openapiElement = new OpenapiElement(stringElement.toValue());
+      this.copyMetaAndAttributes(stringElement, openapiElement);
+      this.element = openapiElement;
+      return BREAK;
+    }
+  }
+});
+export default OpenapiVisitor;

package/es/refractor/visitors/open-api-3-0/ParametersVisitor.js

@@ -0,0 +1,27 @@
+import stampit from 'stampit';
+import { ArrayElement, BREAK } from '@swagger-api/apidom-core';
+import FallbackVisitor from "../FallbackVisitor.js";
+import SpecificationVisitor from "../SpecificationVisitor.js";
+import { isReferenceLikeElement } from "../../predicates.js";
+import { isReferenceElement } from "../../../predicates.js";
+const ParametersVisitor = stampit(SpecificationVisitor, FallbackVisitor, {
+  init() {
+    this.element = new ArrayElement();
+    this.element.classes.push('parameters');
+  },
+  methods: {
+    ArrayElement(arrayElement) {
+      arrayElement.forEach(item => {
+        const specPath = isReferenceLikeElement(item) ? ['document', 'objects', 'Reference'] : ['document', 'objects', 'Parameter'];
+        const element = this.toRefractedElement(specPath, item);
+        if (isReferenceElement(element)) {
+          element.setMetaProperty('referenced-element', 'parameter');
+        }
+        this.element.push(element);
+      });
+      this.copyMetaAndAttributes(arrayElement, this.element);
+      return BREAK;
+    }
+  }
+});
+export default ParametersVisitor;

package/es/refractor/visitors/open-api-3-0/SecurityVisitor.js

@@ -0,0 +1,25 @@
+import stampit from 'stampit';
+import { isObjectElement, BREAK } from '@swagger-api/apidom-core';
+import SecurityElement from "../../../elements/nces/Security.js";
+import SpecificationVisitor from "../SpecificationVisitor.js";
+import FallbackVisitor from "../FallbackVisitor.js";
+const SecurityVisitor = stampit(SpecificationVisitor, FallbackVisitor, {
+  init() {
+    this.element = new SecurityElement();
+  },
+  methods: {
+    ArrayElement(arrayElement) {
+      arrayElement.forEach(item => {
+        if (isObjectElement(item)) {
+          const element = this.toRefractedElement(['document', 'objects', 'SecurityRequirement'], item);
+          this.element.push(element);
+        } else {
+          this.element.push(item.clone());
+        }
+      });
+      this.copyMetaAndAttributes(arrayElement, this.element);
+      return BREAK;
+    }
+  }
+});
+export default SecurityVisitor;

package/es/refractor/visitors/open-api-3-0/ServersVisitor.js

@@ -0,0 +1,23 @@
+import stampit from 'stampit';
+import { BREAK } from '@swagger-api/apidom-core';
+import ServersElement from "../../../elements/nces/Servers.js";
+import SpecificationVisitor from "../SpecificationVisitor.js";
+import FallbackVisitor from "../FallbackVisitor.js";
+import { isServerLikeElement } from "../../predicates.js";
+const ServersVisitor = stampit(SpecificationVisitor, FallbackVisitor, {
+  init() {
+    this.element = new ServersElement();
+  },
+  methods: {
+    ArrayElement(arrayElement) {
+      arrayElement.forEach(item => {
+        const specPath = isServerLikeElement(item) ? ['document', 'objects', 'Server'] : ['value'];
+        const element = this.toRefractedElement(specPath, item);
+        this.element.push(element);
+      });
+      this.copyMetaAndAttributes(arrayElement, this.element);
+      return BREAK;
+    }
+  }
+});
+export default ServersVisitor;

package/es/refractor/visitors/open-api-3-0/TagsVisitor.js

@@ -0,0 +1,23 @@
+import stampit from 'stampit';
+import { BREAK } from '@swagger-api/apidom-core';
+import TagsElement from "../../../elements/nces/Tags.js";
+import SpecificationVisitor from "../SpecificationVisitor.js";
+import FallbackVisitor from "../FallbackVisitor.js";
+import { isTagLikeElement } from "../../predicates.js";
+const TagsVisitor = stampit(SpecificationVisitor, FallbackVisitor, {
+  init() {
+    this.element = new TagsElement();
+  },
+  methods: {
+    ArrayElement(arrayElement) {
+      arrayElement.forEach(item => {
+        const specPath = isTagLikeElement(item) ? ['document', 'objects', 'Tag'] : ['value'];
+        const element = this.toRefractedElement(specPath, item);
+        this.element.push(element);
+      });
+      this.copyMetaAndAttributes(arrayElement, this.element);
+      return BREAK;
+    }
+  }
+});
+export default TagsVisitor;

package/es/refractor/visitors/open-api-3-0/callback/index.js

@@ -0,0 +1,30 @@
+import stampit from 'stampit';
+import { test, always } from 'ramda';
+import CallbackElement from "../../../../elements/Callback.js";
+import PatternedFieldsVisitor from "../../generics/PatternedFieldsVisitor.js";
+import FallbackVisitor from "../../FallbackVisitor.js";
+import MapVisitor from "../../generics/MapVisitor.js";
+import { isPathItemElement } from "../../../../predicates.js";
+const CallbackVisitor = stampit(PatternedFieldsVisitor, FallbackVisitor, {
+  props: {
+    fieldPatternPredicate: test(/{(?<expression>.*)}/),
+    specPath: always(['document', 'objects', 'PathItem']),
+    canSupportSpecificationExtensions: true
+  },
+  init() {
+    this.element = new CallbackElement();
+  },
+  methods: {
+    ObjectElement(objectElement) {
+      // @ts-ignore
+      const result = MapVisitor.compose.methods.ObjectElement.call(this, objectElement);
+
+      // decorate every PathItemElement with Callback Object expression metadata
+      this.element.filter(isPathItemElement).forEach((pathItemElement, key) => {
+        pathItemElement.setMetaProperty('runtime-expression', key.toValue());
+      });
+      return result;
+    }
+  }
+});
+export default CallbackVisitor;

package/es/refractor/visitors/open-api-3-0/components/CallbacksVisitor.js

@@ -0,0 +1,28 @@
+import stampit from 'stampit';
+import ComponentsCallbacksElement from "../../../../elements/nces/ComponentsCallbacks.js";
+import MapVisitor from "../../generics/MapVisitor.js";
+import FallbackVisitor from "../../FallbackVisitor.js";
+import { isReferenceLikeElement } from "../../../predicates.js";
+import { isReferenceElement } from "../../../../predicates.js";
+const CallbacksElement = stampit(MapVisitor, FallbackVisitor, {
+  props: {
+    specPath: element => {
+      // eslint-disable-next-line no-nested-ternary
+      return isReferenceLikeElement(element) ? ['document', 'objects', 'Reference'] : ['document', 'objects', 'Callback'];
+    }
+  },
+  init() {
+    this.element = new ComponentsCallbacksElement();
+  },
+  methods: {
+    ObjectElement(objectElement) {
+      // @ts-ignore
+      const result = MapVisitor.compose.methods.ObjectElement.call(this, objectElement);
+      this.element.filter(isReferenceElement).forEach(referenceElement => {
+        referenceElement.setMetaProperty('referenced-element', 'callback');
+      });
+      return result;
+    }
+  }
+});
+export default CallbacksElement;

package/es/refractor/visitors/open-api-3-0/components/ExamplesVisitor.js

@@ -0,0 +1,30 @@
+import stampit from 'stampit';
+import ComponentsExamplesElement from "../../../../elements/nces/ComponentsExamples.js";
+import MapVisitor from "../../generics/MapVisitor.js";
+import FallbackVisitor from "../../FallbackVisitor.js";
+import { isReferenceLikeElement } from "../../../predicates.js";
+import { isReferenceElement } from "../../../../predicates.js";
+const ExamplesVisitor = stampit(MapVisitor, FallbackVisitor, {
+  props: {
+    specPath: element => {
+      // eslint-disable-next-line no-nested-ternary
+      return isReferenceLikeElement(element) ? ['document', 'objects', 'Reference'] : ['document', 'objects', 'Example'];
+    }
+  },
+  init() {
+    this.element = new ComponentsExamplesElement();
+  },
+  methods: {
+    ObjectElement(objectElement) {
+      // @ts-ignore
+      const result = MapVisitor.compose.methods.ObjectElement.call(this, objectElement);
+
+      // decorate every ReferenceElement with metadata about their referencing type
+      this.element.filter(isReferenceElement).forEach(referenceElement => {
+        referenceElement.setMetaProperty('referenced-element', 'example');
+      });
+      return result;
+    }
+  }
+});
+export default ExamplesVisitor;

package/es/refractor/visitors/open-api-3-0/components/HeadersVisitor.js

@@ -0,0 +1,35 @@
+import stampit from 'stampit';
+import ComponentsHeadersElement from "../../../../elements/nces/ComponentsHeaders.js";
+import MapVisitor from "../../generics/MapVisitor.js";
+import FallbackVisitor from "../../FallbackVisitor.js";
+import { isReferenceLikeElement } from "../../../predicates.js";
+import { isReferenceElement, isHeaderElement } from "../../../../predicates.js";
+const HeadersVisitor = stampit(MapVisitor, FallbackVisitor, {
+  props: {
+    specPath: element => {
+      // eslint-disable-next-line no-nested-ternary
+      return isReferenceLikeElement(element) ? ['document', 'objects', 'Reference'] : ['document', 'objects', 'Header'];
+    }
+  },
+  init() {
+    this.element = new ComponentsHeadersElement();
+  },
+  methods: {
+    ObjectElement(objectElement) {
+      // @ts-ignore
+      const result = MapVisitor.compose.methods.ObjectElement.call(this, objectElement);
+
+      // decorate every ReferenceElement with metadata about their referencing type
+      this.element.filter(isReferenceElement).forEach(referenceElement => {
+        referenceElement.setMetaProperty('referenced-element', 'header');
+      });
+
+      // decorate every HeaderElement with metadata about their name
+      this.element.filter(isHeaderElement).forEach((value, key) => {
+        value.setMetaProperty('header-name', key.toValue());
+      });
+      return result;
+    }
+  }
+});
+export default HeadersVisitor;

package/es/refractor/visitors/open-api-3-0/components/LinksVisitor.js

@@ -0,0 +1,28 @@
+import stampit from 'stampit';
+import ComponentsLinksElement from "../../../../elements/nces/ComponentsLinks.js";
+import MapVisitor from "../../generics/MapVisitor.js";
+import FallbackVisitor from "../../FallbackVisitor.js";
+import { isReferenceLikeElement } from "../../../predicates.js";
+import { isReferenceElement } from "../../../../predicates.js";
+const LinksVisitor = stampit(MapVisitor, FallbackVisitor, {
+  props: {
+    specPath: element => {
+      // eslint-disable-next-line no-nested-ternary
+      return isReferenceLikeElement(element) ? ['document', 'objects', 'Reference'] : ['document', 'objects', 'Link'];
+    }
+  },
+  init() {
+    this.element = new ComponentsLinksElement();
+  },
+  methods: {
+    ObjectElement(objectElement) {
+      // @ts-ignore
+      const result = MapVisitor.compose.methods.ObjectElement.call(this, objectElement);
+      this.element.filter(isReferenceElement).forEach(referenceElement => {
+        referenceElement.setMetaProperty('referenced-element', 'link');
+      });
+      return result;
+    }
+  }
+});
+export default LinksVisitor;

package/es/refractor/visitors/open-api-3-0/components/ParametersVisitor.js

@@ -0,0 +1,30 @@
+import stampit from 'stampit';
+import ComponentsParametersElement from "../../../../elements/nces/ComponentsParameters.js";
+import MapVisitor from "../../generics/MapVisitor.js";
+import FallbackVisitor from "../../FallbackVisitor.js";
+import { isReferenceLikeElement } from "../../../predicates.js";
+import { isReferenceElement } from "../../../../predicates.js";
+const ParametersVisitor = stampit(MapVisitor, FallbackVisitor, {
+  props: {
+    specPath: element => {
+      // eslint-disable-next-line no-nested-ternary
+      return isReferenceLikeElement(element) ? ['document', 'objects', 'Reference'] : ['document', 'objects', 'Parameter'];
+    }
+  },
+  init() {
+    this.element = new ComponentsParametersElement();
+  },
+  methods: {
+    ObjectElement(objectElement) {
+      // @ts-ignore
+      const result = MapVisitor.compose.methods.ObjectElement.call(this, objectElement);
+
+      // decorate every ReferenceElement with metadata about their referencing type
+      this.element.filter(isReferenceElement).forEach(referenceElement => {
+        referenceElement.setMetaProperty('referenced-element', 'parameter');
+      });
+      return result;
+    }
+  }
+});
+export default ParametersVisitor;

package/es/refractor/visitors/open-api-3-0/components/RequestBodiesVisitor.js

@@ -0,0 +1,28 @@
+import stampit from 'stampit';
+import ComponentsRequestBodiesElement from "../../../../elements/nces/ComponentsRequestBodies.js";
+import MapVisitor from "../../generics/MapVisitor.js";
+import FallbackVisitor from "../../FallbackVisitor.js";
+import { isReferenceLikeElement } from "../../../predicates.js";
+import { isReferenceElement } from "../../../../predicates.js";
+const RequestBodiesVisitor = stampit(MapVisitor, FallbackVisitor, {
+  props: {
+    specPath: element => {
+      // eslint-disable-next-line no-nested-ternary
+      return isReferenceLikeElement(element) ? ['document', 'objects', 'Reference'] : ['document', 'objects', 'RequestBody'];
+    }
+  },
+  init() {
+    this.element = new ComponentsRequestBodiesElement();
+  },
+  methods: {
+    ObjectElement(objectElement) {
+      // @ts-ignore
+      const result = MapVisitor.compose.methods.ObjectElement.call(this, objectElement);
+      this.element.filter(isReferenceElement).forEach(referenceElement => {
+        referenceElement.setMetaProperty('referenced-element', 'requestBody');
+      });
+      return result;
+    }
+  }
+});
+export default RequestBodiesVisitor;