source: node_modules/@swagger-api/apidom-reference/es/resolve/strategies/asyncapi-2/visitor.mjs

import stampit from 'stampit';
import { propEq, values, has, pipe } from 'ramda';
import { allP } from 'ramda-adjunct';
import { isPrimitiveElement, isStringElement, visit, toValue } from '@swagger-api/apidom-core';
import { ApiDOMError } from '@swagger-api/apidom-error';
import { evaluate, uriToPointer } from '@swagger-api/apidom-json-pointer';
import { getNodeType, isReferenceElement, isChannelItemElement, isReferenceLikeElement, keyMap, ReferenceElement, ChannelItemElement } from '@swagger-api/apidom-ns-asyncapi-2';
import MaximumDereferenceDepthError from "../../../errors/MaximumDereferenceDepthError.mjs";
import MaximumResolveDepthError from "../../../errors/MaximumResolveDepthError.mjs";
import * as url from "../../../util/url.mjs";
import parse from "../../../parse/index.mjs";
import Reference from "../../../Reference.mjs"; // @ts-ignore
const visitAsync = visit[Symbol.for('nodejs.util.promisify.custom')];
const AsyncApi2ResolveVisitor = stampit({
  props: {
    indirections: [],
    namespace: null,
    reference: null,
    crawledElements: null,
    crawlingMap: null,
    options: null
  },
  init({
    reference,
    namespace,
    indirections = [],
    options
  }) {
    this.indirections = indirections;
    this.namespace = namespace;
    this.reference = reference;
    this.crawledElements = [];
    this.crawlingMap = {};
    this.options = options;
  },
  methods: {
    toBaseURI(uri) {
      return url.resolve(this.reference.uri, url.sanitize(url.stripHash(uri)));
    },
    async toReference(uri) {
      // detect maximum depth of resolution
      if (this.reference.depth >= this.options.resolve.maxDepth) {
        throw new MaximumResolveDepthError(`Maximum resolution depth of ${this.options.resolve.maxDepth} has been exceeded by file "${this.reference.uri}"`);
      }
      const baseURI = this.toBaseURI(uri);
      const {
        refSet
      } = this.reference;

      // we've already processed this Reference in past
      if (refSet.has(baseURI)) {
        return refSet.find(propEq(baseURI, 'uri'));
      }
      const parseResult = await parse(url.unsanitize(baseURI), {
        ...this.options,
        parse: {
          ...this.options.parse,
          mediaType: 'text/plain'
        }
      });

      // register new Reference with ReferenceSet
      const reference = Reference({
        uri: baseURI,
        value: parseResult,
        depth: this.reference.depth + 1
      });
      refSet.add(reference);
      return reference;
    },
    ReferenceElement(referenceElement) {
      const uri = toValue(referenceElement.$ref);
      const retrievalURI = this.toBaseURI(uri);

      // ignore resolving external Reference Objects
      if (!this.options.resolve.external && url.stripHash(this.reference.uri) !== retrievalURI) {
        return false;
      }
      if (!has(retrievalURI, this.crawlingMap)) {
        this.crawlingMap[retrievalURI] = this.toReference(uri);
      }
      this.crawledElements.push(referenceElement);
      return undefined;
    },
    ChannelItemElement(channelItemElement) {
      // ignore PathItemElement without $ref field
      if (!isStringElement(channelItemElement.$ref)) {
        return undefined;
      }
      const uri = toValue(channelItemElement.$ref);
      const retrievalURI = this.toBaseURI(uri);

      // ignore resolving external Channel Item Objects
      if (!this.options.resolve.external && url.stripHash(this.reference.uri) !== retrievalURI) {
        return undefined;
      }
      if (!has(retrievalURI, this.crawlingMap)) {
        this.crawlingMap[retrievalURI] = this.toReference(uri);
      }
      this.crawledElements.push(channelItemElement);
      return undefined;
    },
    async crawlReferenceElement(referenceElement) {
      // @ts-ignore
      const reference = await this.toReference(toValue(referenceElement.$ref));
      this.indirections.push(referenceElement);
      const jsonPointer = uriToPointer(toValue(referenceElement.$ref));

      // possibly non-semantic fragment
      let fragment = evaluate(jsonPointer, reference.value.result);

      // applying semantics to a fragment
      if (isPrimitiveElement(fragment)) {
        const referencedElementType = toValue(referenceElement.meta.get('referenced-element'));
        if (isReferenceLikeElement(fragment)) {
          // handling indirect references
          fragment = ReferenceElement.refract(fragment);
          fragment.setMetaProperty('referenced-element', referencedElementType);
        } else {
          // handling direct references
          const ElementClass = this.namespace.getElementClass(referencedElementType);
          fragment = ElementClass.refract(fragment);
        }
      }

      // detect direct or circular reference
      if (this.indirections.includes(fragment)) {
        throw new ApiDOMError('Recursive Reference Object detected');
      }

      // detect maximum depth of dereferencing
      if (this.indirections.length > this.options.dereference.maxDepth) {
        throw new MaximumDereferenceDepthError(`Maximum dereference depth of "${this.options.dereference.maxDepth}" has been exceeded in file "${this.reference.uri}"`);
      }

      // dive deep into the fragment
      const visitor = AsyncApi2ResolveVisitor({
        reference,
        namespace: this.namespace,
        indirections: [...this.indirections],
        options: this.options
      });
      await visitAsync(fragment, visitor, {
        keyMap,
        nodeTypeGetter: getNodeType
      });
      await visitor.crawl();
      this.indirections.pop();
    },
    async crawlChannelItemElement(channelItemElement) {
      const reference = await this.toReference(toValue(channelItemElement.$ref));
      this.indirections.push(channelItemElement);
      const jsonPointer = uriToPointer(toValue(channelItemElement.$ref));

      // possibly non-semantic referenced element
      let referencedElement = evaluate(jsonPointer, reference.value.result);

      // applying semantics to a referenced element
      if (isPrimitiveElement(referencedElement)) {
        referencedElement = ChannelItemElement.refract(referencedElement);
      }

      // detect direct or indirect reference
      if (this.indirections.includes(referencedElement)) {
        throw new ApiDOMError('Recursive Channel Item Object reference detected');
      }

      // detect maximum depth of dereferencing
      if (this.indirections.length > this.options.dereference.maxDepth) {
        throw new MaximumDereferenceDepthError(`Maximum dereference depth of "${this.options.dereference.maxDepth}" has been exceeded in file "${this.reference.uri}"`);
      }

      // dive deep into the referenced element
      const visitor = AsyncApi2ResolveVisitor({
        reference,
        namespace: this.namespace,
        indirections: [...this.indirections],
        options: this.options
      });
      await visitAsync(referencedElement, visitor, {
        keyMap,
        nodeTypeGetter: getNodeType
      });
      await visitor.crawl();
      this.indirections.pop();
    },
    async crawl() {
      /**
       * Synchronize all parallel resolutions in this place.
       * After synchronization happened we can be sure that refSet
       * contains resolved Reference objects.
       */
      await pipe(values, allP)(this.crawlingMap);
      this.crawlingMap = null;

      /* eslint-disable no-await-in-loop */
      for (const element of this.crawledElements) {
        if (isReferenceElement(element)) {
          await this.crawlReferenceElement(element);
        } else if (isChannelItemElement(element)) {
          await this.crawlChannelItemElement(element);
        }
      }
      /* eslint-enabled */
    }
  }
});
export default AsyncApi2ResolveVisitor;