@swagger-api/apidom-ns-openapi-2 0.93.0 → 0.94.0

package/es/refractor/index.mjs

@@ -1,5 +1,5 @@
-import { invokeArgs } from 'ramda-adjunct';
 import { visit, dereference, refract as baseRefract, dispatchRefractorPlugins } from '@swagger-api/apidom-core';
+import { path } from 'ramda';
 import specification from "./specification.mjs";
 import { keyMap, getNodeType } from "../traversal/visitor.mjs";
 import createToolbox from "./toolbox.mjs";
@@ -15,13 +15,11 @@ const refract = (value, {
    * We don't allow consumers to hook into this translation.
    * Though we allow consumers to define their onw plugins on already transformed ApiDOM.
    */
-  const rootVisitor = invokeArgs(specPath, [], resolvedSpec);
-  // @ts-ignore
-  visit(element, rootVisitor, {
-    state: {
-      specObj: resolvedSpec
-    }
+  const RootVistorClass = path(specPath, resolvedSpec);
+  const rootVisitor = new RootVistorClass({
+    specObj: resolvedSpec
   });
+  visit(element, rootVisitor);
 
   /**
    * Running plugins visitors means extra single traversal === performance hit.

package/es/refractor/visitors/FallbackVisitor.mjs

@@ -1,4 +1,3 @@
-import stampit from 'stampit';
 import { BREAK, cloneDeep } from '@swagger-api/apidom-core';
 import Visitor from "./Visitor.mjs";
 /**
@@ -7,12 +6,10 @@ import Visitor from "./Visitor.mjs";
  * different Element is provided FallBackVisitor is responsible to assigning
  * this Element as current element.
  */
-const FallbackVisitor = stampit(Visitor, {
-  methods: {
-    enter(element) {
-      this.element = cloneDeep(element);
-      return BREAK;
-    }
+class FallbackVisitor extends Visitor {
+  enter(element) {
+    this.element = cloneDeep(element);
+    return BREAK;
   }
-});
+}
 export default FallbackVisitor;

package/es/refractor/visitors/SpecificationExtensionVisitor.mjs

@@ -1,13 +1,10 @@
-import stampit from 'stampit';
 import { BREAK, cloneDeep } from '@swagger-api/apidom-core';
 import SpecificationVisitor from "./SpecificationVisitor.mjs";
-const SpecificationExtensionVisitor = stampit(SpecificationVisitor, {
-  methods: {
-    MemberElement(memberElement) {
-      this.element = cloneDeep(memberElement);
-      this.element.classes.push('specification-extension');
-      return BREAK;
-    }
+class SpecificationExtensionVisitor extends SpecificationVisitor {
+  MemberElement(memberElement) {
+    this.element = cloneDeep(memberElement);
+    this.element.classes.push('specification-extension');
+    return BREAK;
   }
-});
+}
 export default SpecificationExtensionVisitor;

package/es/refractor/visitors/SpecificationVisitor.mjs

@@ -1,74 +1,71 @@
-import stampit from 'stampit';
 import { pathSatisfies, path, pick } from 'ramda';
-import { isFunction, isUndefined } from 'ramda-adjunct';
+import { isFunction } from 'ramda-adjunct';
 import { visit, cloneDeep } from '@swagger-api/apidom-core';
-import Visitor from "./Visitor.mjs";
 import { keyMap, getNodeType } from "../../traversal/visitor.mjs";
+import Visitor from "./Visitor.mjs";
+import FallbackVisitor from "./FallbackVisitor.mjs";
 /**
  * This is a base Type for every visitor that does
  * internal look-ups to retrieve other child visitors.
  */
-const SpecificationVisitor = stampit(Visitor, {
-  props: {
-    specObj: null,
-    passingOptionsNames: ['specObj']
-  },
-  init({
-    // @ts-ignoreh
-    specObj = this.specObj
+class SpecificationVisitor extends Visitor {
+  specObj;
+  passingOptionsNames = ['specObj'];
+  constructor({
+    specObj,
+    ...rest
   }) {
+    super({
+      ...rest
+    });
     this.specObj = specObj;
-  },
-  methods: {
-    retrievePassingOptions() {
-      return pick(this.passingOptionsNames, this);
-    },
-    retrieveFixedFields(specPath) {
-      const fixedFields = path(['visitors', ...specPath, 'fixedFields'], this.specObj);
-      if (typeof fixedFields === 'object' && fixedFields !== null) {
-        return Object.keys(fixedFields);
-      }
-      return [];
-    },
-    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)({
-        ...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 cloneDeep(element);
-      }
-
-      // standard processing continues
-      visit(element, visitor, {
-        keyMap,
-        nodeTypeGetter: getNodeType,
-        ...options
-      });
-      return visitor.element;
+  }
+  retrievePassingOptions() {
+    return pick(this.passingOptionsNames, this);
+  }
+  retrieveFixedFields(specPath) {
+    const fixedFields = path(['visitors', ...specPath, 'fixedFields'], this.specObj);
+    if (typeof fixedFields === 'object' && fixedFields !== null) {
+      return Object.keys(fixedFields);
     }
+    return [];
+  }
+  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();
+    const VisitorClz = this.retrieveVisitor(specPath);
+    const visitorOpts = {
+      ...passingOpts,
+      ...options
+    };
+    return new VisitorClz(visitorOpts);
+  }
+  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);
+    if (visitor instanceof FallbackVisitor && (visitor === null || visitor === void 0 ? void 0 : visitor.constructor) === FallbackVisitor) {
+      return cloneDeep(element);
+    }
+
+    // @ts-ignore
+    visit(element, visitor, {
+      keyMap,
+      nodeTypeGetter: getNodeType,
+      ...options
+    });
+    return visitor.element;
   }
-});
+}
 export default SpecificationVisitor;

package/es/refractor/visitors/Visitor.mjs

@@ -1,16 +1,16 @@
-import stampit from 'stampit';
 import { hasElementSourceMap } from '@swagger-api/apidom-core';
-const Visitor = stampit({
-  props: {
-    element: null
-  },
-  methods: {
-    copyMetaAndAttributes(from, to) {
-      // copy sourcemaps
-      if (hasElementSourceMap(from)) {
-        to.meta.set('sourceMap', from.meta.get('sourceMap'));
-      }
+class Visitor {
+  element;
+  constructor(options = {}) {
+    Object.assign(this, options);
+  }
+
+  // eslint-disable-next-line class-methods-use-this
+  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.mjs

@@ -1,22 +1,26 @@
-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.mjs";
-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;
-    }
+class AlternatingVisitor extends SpecificationVisitor {
+  alternator;
+  constructor({
+    alternator,
+    ...rest
+  }) {
+    super({
+      ...rest
+    });
+    this.alternator = alternator || [];
   }
-});
+  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.mjs

@@ -1,51 +1,51 @@
-import stampit from 'stampit';
-import { noop } from 'ramda-adjunct';
 import { isStringElement, MemberElement, BREAK, cloneDeep, toValue } from '@swagger-api/apidom-core';
 import SpecificationVisitor from "../SpecificationVisitor.mjs";
 import { isSwaggerExtension } from "../../predicates.mjs";
-const FixedFieldsVisitor = stampit(SpecificationVisitor, {
-  props: {
-    specPath: noop,
-    ignoredFields: [],
-    canSupportSpecificationExtensions: true,
-    specificationExtensionPredicate: isSwaggerExtension
-  },
-  init({
-    // @ts-ignore
-    specPath = this.specPath,
-    // @ts-ignore
-    ignoredFields = this.ignoredFields,
-    // @ts-ignore
-    canSupportSpecificationExtensions = this.canSupportSpecificationExtensions,
-    // @ts-ignore
-    specificationExtensionPredicate = this.specificationExtensionPredicate
-  } = {}) {
+class FixedFieldsVisitor extends SpecificationVisitor {
+  specPath;
+  ignoredFields;
+  canSupportSpecificationExtensions = true;
+  specificationExtensionPredicate = isSwaggerExtension;
+  constructor({
+    specPath,
+    ignoredFields,
+    canSupportSpecificationExtensions,
+    specificationExtensionPredicate,
+    ...rest
+  }) {
+    super({
+      ...rest
+    });
     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(toValue(key)) && !this.ignoredFields.includes(toValue(key))) {
-          const fixedFieldElement = this.toRefractedElement([...specPath, 'fixedFields', toValue(key)], value);
-          const newMemberElement = new MemberElement(cloneDeep(key), 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(toValue(key))) {
-          this.element.content.push(cloneDeep(memberElement));
-        }
-      });
-      this.copyMetaAndAttributes(objectElement, this.element);
-      return BREAK;
+    this.ignoredFields = ignoredFields || [];
+    if (typeof canSupportSpecificationExtensions === 'boolean') {
+      this.canSupportSpecificationExtensions = canSupportSpecificationExtensions;
     }
+    if (typeof specificationExtensionPredicate === 'function') {
+      this.specificationExtensionPredicate = specificationExtensionPredicate;
+    }
+  }
+  ObjectElement(objectElement) {
+    const specPath = this.specPath(objectElement);
+    const fields = this.retrieveFixedFields(specPath);
+
+    // @ts-ignore
+    objectElement.forEach((value, key, memberElement) => {
+      if (isStringElement(key) && fields.includes(toValue(key)) && !this.ignoredFields.includes(toValue(key))) {
+        const fixedFieldElement = this.toRefractedElement([...specPath, 'fixedFields', toValue(key)], value);
+        const newMemberElement = new MemberElement(cloneDeep(key), 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(toValue(key))) {
+        this.element.content.push(cloneDeep(memberElement));
+      }
+    });
+    this.copyMetaAndAttributes(objectElement, this.element);
+    return BREAK;
   }
-});
+}
 export default FixedFieldsVisitor;

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

@@ -1,9 +1,9 @@
-import stampit from 'stampit';
 import { isNonEmptyString } from 'ramda-adjunct';
 import PatternedFieldsVisitor from "./PatternedFieldsVisitor.mjs";
-const MapVisitor = stampit(PatternedFieldsVisitor, {
-  props: {
-    fieldPatternPredicate: isNonEmptyString
+class MapVisitor extends PatternedFieldsVisitor {
+  constructor(options) {
+    super(options);
+    this.fieldPatternPredicate = isNonEmptyString;
   }
-});
+}
 export default MapVisitor;

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

@@ -1,37 +1,42 @@
-import stampit from 'stampit';
+import { Mixin } from 'ts-mixer';
 import { difference } from 'ramda';
-import { noop } from 'ramda-adjunct';
 import { BREAK } from '@swagger-api/apidom-core';
 import FixedFieldsVisitor from "./FixedFieldsVisitor.mjs";
 import PatternedFieldsVisitor from "./PatternedFieldsVisitor.mjs";
-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;
+class MixedFieldsVisitor extends Mixin(FixedFieldsVisitor, PatternedFieldsVisitor) {
+  specPathFixedFields;
+  specPathPatternedFields;
+  constructor({
+    specPathFixedFields,
+    specPathPatternedFields,
+    ...rest
+  }) {
+    super({
+      ...rest
+    });
+    this.specPathFixedFields = specPathFixedFields;
+    this.specPathPatternedFields = specPathPatternedFields;
+  }
+  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
+      // @ts-ignore
+      this.ignoredFields = [...ignoredFields, ...difference(objectElement.keys(), fixedFields)];
+      FixedFieldsVisitor.prototype.ObjectElement.call(this, objectElement);
+      this.specPath = this.specPathPatternedFields;
+      this.ignoredFields = fixedFields;
+      PatternedFieldsVisitor.prototype.ObjectElement.call(this, objectElement);
+    } catch (e) {
+      this.specPath = specPath;
+      throw e;
     }
+    return BREAK;
   }
-});
+}
 export default MixedFieldsVisitor;

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

@@ -1,53 +1,55 @@
-import stampit from 'stampit';
 import { F as stubFalse } from 'ramda';
-import { noop } from 'ramda-adjunct';
 import { MemberElement, BREAK, cloneDeep, toValue } from '@swagger-api/apidom-core';
 import SpecificationVisitor from "../SpecificationVisitor.mjs";
 import { isSwaggerExtension } from "../../predicates.mjs";
-const PatternedFieldsJsonObjectVisitor = stampit(SpecificationVisitor, {
-  props: {
-    fieldPatternPredicate: stubFalse,
-    specPath: noop,
-    ignoredFields: [],
-    canSupportSpecificationExtensions: false,
-    specificationExtensionPredicate: isSwaggerExtension
-  },
-  init({
-    // @ts-ignore
-    specPath = this.specPath,
-    // @ts-ignore
-    ignoredFields = this.ignoredFields,
-    // @ts-ignore
-    canSupportSpecificationExtensions = this.canSupportSpecificationExtensions,
-    // @ts-ignore
-    specificationExtensionPredicate = this.specificationExtensionPredicate
-  } = {}) {
+class PatternedFieldsVisitor extends SpecificationVisitor {
+  specPath;
+  ignoredFields;
+  fieldPatternPredicate = stubFalse;
+  canSupportSpecificationExtensions = false;
+  specificationExtensionPredicate = isSwaggerExtension;
+  constructor({
+    specPath,
+    ignoredFields,
+    fieldPatternPredicate,
+    canSupportSpecificationExtensions,
+    specificationExtensionPredicate,
+    ...rest
+  }) {
+    super({
+      ...rest
+    });
     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(toValue(key)) && this.fieldPatternPredicate(toValue(key))) {
-          const specPath = this.specPath(value);
-          const patternedFieldElement = this.toRefractedElement(specPath, value);
-          const newMemberElement = new MemberElement(cloneDeep(key), patternedFieldElement);
-          this.copyMetaAndAttributes(memberElement, newMemberElement);
-          newMemberElement.classes.push('patterned-field');
-          this.element.content.push(newMemberElement);
-        } else if (!this.ignoredFields.includes(toValue(key))) {
-          this.element.content.push(cloneDeep(memberElement));
-        }
-      });
-      this.copyMetaAndAttributes(objectElement, this.element);
-      return BREAK;
+    this.ignoredFields = ignoredFields || [];
+    if (typeof fieldPatternPredicate === 'function') {
+      this.fieldPatternPredicate = fieldPatternPredicate;
     }
+    if (typeof canSupportSpecificationExtensions === 'boolean') {
+      this.canSupportSpecificationExtensions = canSupportSpecificationExtensions;
+    }
+    if (typeof specificationExtensionPredicate === 'function') {
+      this.specificationExtensionPredicate = specificationExtensionPredicate;
+    }
+  }
+  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(toValue(key)) && this.fieldPatternPredicate(toValue(key))) {
+        const specPath = this.specPath(value);
+        const patternedFieldElement = this.toRefractedElement(specPath, value);
+        const newMemberElement = new MemberElement(cloneDeep(key), patternedFieldElement);
+        this.copyMetaAndAttributes(memberElement, newMemberElement);
+        newMemberElement.classes.push('patterned-field');
+        this.element.content.push(newMemberElement);
+      } else if (!this.ignoredFields.includes(toValue(key))) {
+        this.element.content.push(cloneDeep(memberElement));
+      }
+    });
+    this.copyMetaAndAttributes(objectElement, this.element);
+    return BREAK;
   }
-});
-export default PatternedFieldsJsonObjectVisitor;
+}
+export default PatternedFieldsVisitor;

package/es/refractor/visitors/open-api-2/BasePathVisitor.mjs

@@ -1,13 +1,9 @@
-import stampit from 'stampit';
-import { BREAK, cloneDeep } from '@swagger-api/apidom-core';
 import FallbackVisitor from "../FallbackVisitor.mjs";
-const BasePathVisitor = stampit(FallbackVisitor, {
-  methods: {
-    StringElement(stringElement) {
-      this.element = cloneDeep(stringElement);
-      this.element.classes.push('swagger-base-path');
-      return BREAK;
-    }
+class BasePathVisitor extends FallbackVisitor {
+  StringElement(stringElement) {
+    const result = super.enter(stringElement);
+    this.element.classes.push('swagger-base-path');
+    return result;
   }
-});
+}
 export default BasePathVisitor;

package/es/refractor/visitors/open-api-2/ConsumesVisitor.mjs

@@ -1,16 +1,14 @@
-import stampit from 'stampit';
 import { BREAK, cloneDeep } from '@swagger-api/apidom-core';
 import SwaggerConsumesElement from "../../../elements/nces/SwaggerConsumes.mjs";
 import FallbackVisitor from "../FallbackVisitor.mjs";
-const ConsumesVisitor = stampit(FallbackVisitor, {
-  init() {
+class ConsumesVisitor extends FallbackVisitor {
+  constructor(options) {
+    super(options);
     this.element = new SwaggerConsumesElement();
-  },
-  methods: {
-    ArrayElement(arrayElement) {
-      this.element = this.element.concat(cloneDeep(arrayElement));
-      return BREAK;
-    }
   }
-});
+  ArrayElement(arrayElement) {
+    this.element = this.element.concat(cloneDeep(arrayElement));
+    return BREAK;
+  }
+}
 export default ConsumesVisitor;

package/es/refractor/visitors/open-api-2/HostVisitor.mjs

@@ -1,13 +1,9 @@
-import stampit from 'stampit';
-import { BREAK, cloneDeep } from '@swagger-api/apidom-core';
 import FallbackVisitor from "../FallbackVisitor.mjs";
-const HostVisitor = stampit(FallbackVisitor, {
-  methods: {
-    StringElement(stringElement) {
-      this.element = cloneDeep(stringElement);
-      this.element.classes.push('swagger-host');
-      return BREAK;
-    }
+class HostVisitor extends FallbackVisitor {
+  StringElement(stringElement) {
+    const result = super.enter(stringElement);
+    this.element.classes.push('swagger-host');
+    return result;
   }
-});
+}
 export default HostVisitor;

package/es/refractor/visitors/open-api-2/ProducesVisitor.mjs

@@ -1,16 +1,14 @@
-import stampit from 'stampit';
 import { BREAK, cloneDeep } from '@swagger-api/apidom-core';
 import SwaggerProducesElement from "../../../elements/nces/SwaggerProduces.mjs";
 import FallbackVisitor from "../FallbackVisitor.mjs";
-const ProducesVisitor = stampit(FallbackVisitor, {
-  init() {
+class ProducesVisitor extends FallbackVisitor {
+  constructor(options) {
+    super(options);
     this.element = new SwaggerProducesElement();
-  },
-  methods: {
-    ArrayElement(arrayElement) {
-      this.element = this.element.concat(cloneDeep(arrayElement));
-      return BREAK;
-    }
   }
-});
+  ArrayElement(arrayElement) {
+    this.element = this.element.concat(cloneDeep(arrayElement));
+    return BREAK;
+  }
+}
 export default ProducesVisitor;