@swagger-api/apidom-ns-api-design-systems 0.68.1

package/es/predicates.js

@@ -0,0 +1,65 @@
+import { createPredicate } from '@swagger-api/apidom-core';
+import MainElement from "./elements/Main.js";
+import InfoElement from "./elements/Info.js";
+import PrincipleElement from "./elements/Principle.js";
+import RequirementElement from "./elements/Requirement.js";
+import RequirementLevelElement from "./elements/RequirementLevel.js";
+import ScenarioElement from "./elements/Scenario.js";
+import StandardElement from "./elements/Standard.js";
+import StandardIdentifierElement from "./elements/StandardIdentifier.js";
+export const isMainElement = createPredicate(({
+  hasBasicElementProps,
+  isElementType,
+  primitiveEq
+}) => {
+  return element => element instanceof MainElement || hasBasicElementProps(element) && isElementType('main', element) && primitiveEq('object', element);
+});
+export const isInfoElement = createPredicate(({
+  hasBasicElementProps,
+  isElementType,
+  primitiveEq
+}) => {
+  return element => element instanceof InfoElement || hasBasicElementProps(element) && isElementType('info', element) && primitiveEq('object', element);
+});
+export const isPrincipleElement = createPredicate(({
+  hasBasicElementProps,
+  isElementType,
+  primitiveEq
+}) => {
+  return element => element instanceof PrincipleElement || hasBasicElementProps(element) && isElementType('principle', element) && primitiveEq('object', element);
+});
+export const isRequirementElement = createPredicate(({
+  hasBasicElementProps,
+  isElementType,
+  primitiveEq
+}) => {
+  return element => element instanceof RequirementElement || hasBasicElementProps(element) && isElementType('requirement', element) && primitiveEq('object', element);
+});
+export const isRequirementLevelElement = createPredicate(({
+  hasBasicElementProps,
+  isElementType,
+  primitiveEq
+}) => {
+  return element => element instanceof RequirementLevelElement || hasBasicElementProps(element) && isElementType('requirementLevel', element) && primitiveEq('string', element);
+});
+export const isScenarioElement = createPredicate(({
+  hasBasicElementProps,
+  isElementType,
+  primitiveEq
+}) => {
+  return element => element instanceof ScenarioElement || hasBasicElementProps(element) && isElementType('scenario', element) && primitiveEq('object', element);
+});
+export const isStandardElement = createPredicate(({
+  hasBasicElementProps,
+  isElementType,
+  primitiveEq
+}) => {
+  return element => element instanceof StandardElement || hasBasicElementProps(element) && isElementType('standard', element) && primitiveEq('object', element);
+});
+export const isStandardIdentifierElement = createPredicate(({
+  hasBasicElementProps,
+  isElementType,
+  primitiveEq
+}) => {
+  return element => element instanceof StandardIdentifierElement || hasBasicElementProps(element) && isElementType('standardIdentifier', element) && primitiveEq('array', element);
+});

package/es/refractor/index.js

@@ -0,0 +1,43 @@
+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 { visit, dereference, refract as baseRefract, dispatchRefractorPlugins } from '@swagger-api/apidom-core';
+import { invokeArgs } from 'ramda-adjunct';
+import specification from "./specification.js";
+import { keyMap, getNodeType } from "../traversal/visitor.js";
+import createToolbox from "./toolbox.js";
+const refract = (value, {
+  specPath = ['visitors', 'document', 'objects', 'Main', '$visitor'],
+  plugins = []
+} = {}) => {
+  const element = baseRefract(value);
+  const resolvedSpec = dereference(specification);
+
+  /**
+   * This is where generic ApiDOM becomes semantic (namespace applied).
+   * 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
+    }
+  });
+
+  /**
+   * Running plugins visitors means extra single traversal === performance hit.
+   */
+  return dispatchRefractorPlugins(rootVisitor.element, plugins, {
+    toolboxCreator: createToolbox,
+    visitorOptions: {
+      keyMap,
+      nodeTypeGetter: getNodeType
+    }
+  });
+};
+export const createRefractor = specPath => (value, options = {}) => refract(value, _objectSpread(_objectSpread({}, options), {}, {
+  specPath
+}));
+export default refract;

package/es/refractor/plugins/openapi-3-1/standard-identifier-accessors.js

@@ -0,0 +1,83 @@
+import { StringElement } from '@swagger-api/apidom-core';
+import { isStringElement, isArrayElement, isObjectElement } from '@swagger-api/apidom-ns-openapi-3-1';
+const plugin = () => () => {
+  return {
+    visitor: {
+      OperationElement(element, ...rest) {
+        const [,,, ancestors] = rest;
+        const parentPathItem = ancestors[ancestors.length - 2];
+        const httpMethod = element.meta.get('http-method').clone();
+        httpMethod.content = httpMethod.toValue().toLowerCase();
+        const standardIdentifiers = [{
+          subject: ['http', 'request', 'url'],
+          value: parentPathItem.meta.get('path')
+        }, {
+          subject: ['http', 'request', 'method'],
+          value: httpMethod
+        }];
+        if (typeof parentPathItem.parameters !== 'undefined' && isArrayElement(parentPathItem.parameters)) {
+          // @ts-ignore
+          parentPathItem.parameters.forEach(parameter => {
+            var _parameter$in;
+            if (isStringElement(parameter.in) && isStringElement(parameter.name) && ((_parameter$in = parameter.in) === null || _parameter$in === void 0 ? void 0 : _parameter$in.toValue()) === 'header') {
+              var _parameter$name, _parameter$name2;
+              standardIdentifiers.push({
+                subject: ['http', 'request', 'header'],
+                value: (_parameter$name = parameter.name) === null || _parameter$name === void 0 ? void 0 : _parameter$name.clone()
+              });
+              standardIdentifiers.push({
+                subject: ['http', 'message', 'header'],
+                value: (_parameter$name2 = parameter.name) === null || _parameter$name2 === void 0 ? void 0 : _parameter$name2.clone()
+              });
+            }
+          });
+        }
+        element.setMetaProperty('ads-a-standard-identifier', standardIdentifiers);
+      },
+      ParameterElement(element) {
+        var _element$in;
+        if (isStringElement(element.in) && isStringElement(element.name) && ((_element$in = element.in) === null || _element$in === void 0 ? void 0 : _element$in.toValue()) === 'header') {
+          var _element$name, _element$name2;
+          element.setMetaProperty('ads-a-standard-identifier', [{
+            subject: ['http', 'request', 'header'],
+            value: (_element$name = element.name) === null || _element$name === void 0 ? void 0 : _element$name.clone()
+          }, {
+            subject: ['http', 'message', 'header'],
+            value: (_element$name2 = element.name) === null || _element$name2 === void 0 ? void 0 : _element$name2.clone()
+          }]);
+        }
+      },
+      RequestBodyElement(element) {
+        if (typeof element.contentProp === 'undefined' || !isObjectElement(element.contentProp)) {
+          return;
+        }
+        const standardIdentifiers = [];
+        element.contentProp.forEach((mediaType, key) => {
+          standardIdentifiers.push({
+            subject: ['http', 'request', 'header'],
+            value: new StringElement('Content-Type', key.meta.clone())
+          }, {
+            subject: ['http', 'message', 'header'],
+            value: new StringElement('Content-Type', key.meta.clone())
+          }, {
+            subject: ['http', 'request', 'header', 'Content-Type'],
+            value: key.clone()
+          }, {
+            subject: ['http', 'message', 'header', 'Content-Type'],
+            value: key.clone()
+          });
+        });
+        element.setMetaProperty('ads-a-standard-identifier', standardIdentifiers);
+      },
+      ResponseElement(element) {
+        if (!element.meta.hasKey('http-status-code')) return;
+        const standardIdentifiers = [{
+          subject: ['http', 'response', 'status_code'],
+          value: element.meta.get('http-status-code').clone()
+        }];
+        element.setMetaProperty('ads-a-standard-identifier', standardIdentifiers);
+      }
+    }
+  };
+};
+export default plugin;

package/es/refractor/plugins/openapi-3-1/standard-identifier-selectors.js

@@ -0,0 +1,75 @@
+import { isStringElement, isObjectElement } from '@swagger-api/apidom-ns-openapi-3-1';
+const plugin = () => () => {
+  let operationIdentifiers = [];
+  let responseIdentifiers = [];
+  return {
+    visitor: {
+      OperationElement: {
+        enter(element, ...rest) {
+          var _parentPathItem$param;
+          const [,,, ancestors] = rest;
+          const parentPathItem = ancestors[ancestors.length - 2];
+          operationIdentifiers.push(['http', 'transaction'], ['http', 'request'], ['http', 'request', 'url'], ['http', 'request', 'url', parentPathItem.meta.get('path').toValue()], ['http', 'request', 'method'], ['http', 'request', 'method', element.meta.get('http-method').toValue().toLowerCase()]);
+
+          // fold PathItem.parameters to Operation.parameters
+          // @ts-ignore
+          parentPathItem === null || parentPathItem === void 0 ? void 0 : (_parentPathItem$param = parentPathItem.parameters) === null || _parentPathItem$param === void 0 ? void 0 : _parentPathItem$param.forEach(parameter => {
+            var _parameter$in;
+            if (isStringElement(parameter.in) && isStringElement(parameter.name) && ((_parameter$in = parameter.in) === null || _parameter$in === void 0 ? void 0 : _parameter$in.toValue()) === 'header') {
+              var _parameter$name, _parameter$name2;
+              operationIdentifiers.push(['http', 'request', 'header'], ['http', 'request', 'header', (_parameter$name = parameter.name) === null || _parameter$name === void 0 ? void 0 : _parameter$name.toValue()], ['http', 'message', 'header'], ['http', 'message', 'header', (_parameter$name2 = parameter.name) === null || _parameter$name2 === void 0 ? void 0 : _parameter$name2.toValue()]);
+            }
+          });
+        },
+        leave(element) {
+          element.setMetaProperty('ads-s-standard-identifier', operationIdentifiers);
+          operationIdentifiers = [];
+        }
+      },
+      ParameterElement(element) {
+        var _element$in;
+        if (isStringElement(element.in) && isStringElement(element.name) && ((_element$in = element.in) === null || _element$in === void 0 ? void 0 : _element$in.toValue()) === 'header') {
+          var _element$name, _element$name2;
+          operationIdentifiers.push(['http', 'request', 'header'], ['http', 'request', 'header', (_element$name = element.name) === null || _element$name === void 0 ? void 0 : _element$name.toValue()], ['http', 'message', 'header'], ['http', 'message', 'header', (_element$name2 = element.name) === null || _element$name2 === void 0 ? void 0 : _element$name2.toValue()]);
+        }
+      },
+      RequestBodyElement(element) {
+        if (!isObjectElement(element.contentProp)) return;
+        operationIdentifiers.push(['http', 'request', 'body'], ['http', 'message', 'body']);
+        if (typeof element.contentProp !== 'undefined' && isObjectElement(element.contentProp)) {
+          element.contentProp.forEach(() => {
+            operationIdentifiers.push(['http', 'request', 'header'], ['http', 'request', 'header', 'Content-Type'], ['http', 'message', 'header'], ['http', 'message', 'header', 'Content-Type']);
+          });
+        }
+      },
+      ResponseElement: {
+        enter(element) {
+          responseIdentifiers.push(['http', 'response']);
+          if (element.meta.hasKey('http-status-code')) {
+            const statusCode = String(element.meta.get('http-status-code').toValue());
+            const statusCodeAlias = statusCode.startsWith('2') ? 'success' : statusCode.startsWith('3') ? 'redirect' : statusCode.startsWith('4') ? 'client_error' : statusCode.startsWith('5') ? 'sever_error' : 'unknown';
+            responseIdentifiers.push(['http', 'response', 'status_code'], ['http', 'response', 'status_code', statusCode], ['http', 'response', 'status_code', statusCodeAlias]);
+          }
+          if (typeof element.headers !== 'undefined' && isObjectElement(element.headers)) {
+            element.headers.forEach((value, key) => {
+              const headerName = key.toValue();
+              responseIdentifiers.push(['http', 'response', 'header'], ['http', 'response', 'header', headerName], ['http', 'message', 'header', headerName]);
+            });
+          }
+          if (typeof element.contentProp !== 'undefined' && isObjectElement(element.contentProp)) {
+            responseIdentifiers.push(['http', 'response', 'body'], ['http', 'message', 'body']);
+            element.contentProp.forEach((value, key) => {
+              const headerName = key.toValue();
+              responseIdentifiers.push(['http', 'response', 'header'], ['http', 'response', 'header', headerName], ['http', 'message', 'header', headerName]);
+            });
+          }
+        },
+        leave(element) {
+          element.setMetaProperty('ads-s-standard-identifier', responseIdentifiers);
+          responseIdentifiers = [];
+        }
+      }
+    }
+  };
+};
+export default plugin;

package/es/refractor/registration.js

@@ -0,0 +1,24 @@
+import { createRefractor } from "./index.js";
+/**
+ * API Design Systems 2021-05-07 specification elements.
+ */
+import MainElement from "../elements/Main.js";
+import InfoElement from "../elements/Info.js";
+import PrincipleElement from "../elements/Principle.js";
+import RequirementElement from "../elements/Requirement.js";
+import RequirementLevelElement from "../elements/RequirementLevel.js";
+import ScenarioElement from "../elements/Scenario.js";
+import StandardElement from "../elements/Standard.js";
+import StandardIdentifierElement from "../elements/StandardIdentifier.js";
+/**
+ * API Design Systems 2021-05-07 specification elements.
+ */
+MainElement.refract = createRefractor(['visitors', 'document', 'objects', 'Main', '$visitor']);
+InfoElement.refract = createRefractor(['visitors', 'document', 'objects', 'Info', '$visitor']);
+PrincipleElement.refract = createRefractor(['visitors', 'document', 'objects', 'Principle', '$visitor']);
+RequirementElement.refract = createRefractor(['visitors', 'document', 'objects', 'Requirement', '$visitor']);
+RequirementLevelElement.refract = createRefractor(['visitors', 'document', 'objects', 'RequirementLevel', '$visitor']);
+ScenarioElement.refract = createRefractor(['visitors', 'document', 'objects', 'Scenario', '$visitor']);
+StandardElement.refract = createRefractor(['visitors', 'document', 'objects', 'Standards', '$visitor']);
+StandardIdentifierElement.refract = createRefractor(['visitors', 'document', 'objects', 'StandardIdentifier', '$visitor']);
+export { MainElement, InfoElement, PrincipleElement, RequirementElement, RequirementLevelElement, ScenarioElement, StandardElement, StandardIdentifierElement };

package/es/refractor/specification.js

@@ -0,0 +1,115 @@
+import FallbackVisitor from "./visitors/FallbackVisitor.js";
+/**
+ * API Design Systems 2021-05-07 specification elements.
+ */
+import RequirementLevelVisitor from "./visitors/api-design-systems/requirement-level/index.js";
+import StandardIdentifierVisitor from "./visitors/api-design-systems/standard-identifier/index.js";
+import RequirementVisitor from "./visitors/api-design-systems/requirement/index.js";
+import RequirementValuesVisitor from "./visitors/api-design-systems/requirement/ValuesVisitor.js";
+import RequirementFollowsVisitor from "./visitors/api-design-systems/requirement/FollowsVisitor.js";
+import ScenarioVisitor from "./visitors/api-design-systems/scenario/index.js";
+import ScenarioDescriptionVisitor from "./visitors/api-design-systems/scenario/DescriptionVisitor.js";
+import ScenarioThenVisitor from "./visitors/api-design-systems/scenario/ThenVisitor.js";
+import StandardVisitor from "./visitors/api-design-systems/standard/index.js";
+import StandardNameVisitor from "./visitors/api-design-systems/standard/NameVisitor.js";
+import StandardDescriptionVisitor from "./visitors/api-design-systems/standard/DescriptionVisitor.js";
+import StandardIriVisitor from "./visitors/api-design-systems/standard/IriVisitor.js";
+import PrincipleVisitor from "./visitors/api-design-systems/principle/index.js";
+import PrincipleNameVisitor from "./visitors/api-design-systems/principle/NameVisitor.js";
+import PrincipleDescriptionVisitor from "./visitors/api-design-systems/principle/DescriptionVisitor.js";
+import PrincipleIriVisitor from "./visitors/api-design-systems/principle/IriVisitor.js";
+import InfoVisitor from "./visitors/api-design-systems/info/index.js";
+import InfoTitleVisitor from "./visitors/api-design-systems/info/TitleVisitor.js";
+import InfoDescriptionVisitor from "./visitors/api-design-systems/info/DescriptionVisitor.js";
+import MainVisitor from "./visitors/api-design-systems/main/index.js";
+import MainVersionVisitor from "./visitors/api-design-systems/main/VersionVisitor.js";
+import MainPrinciplesVisitor from "./visitors/api-design-systems/main/PrinciplesVisitor.js";
+import MainStandardsVisitor from "./visitors/api-design-systems/main/StandardsVisitor.js";
+import MainScenariosVisitor from "./visitors/api-design-systems/main/ScenariosVisitor.js";
+/**
+ * Specification object allows us to have complete control over visitors
+ * when traversing the ApiDOM.
+ * Specification also allows us to create amended refractors from
+ * existing ones by manipulating it.
+ *
+ * Note: Specification object allows to use absolute internal JSON pointers.
+ */
+const specification = {
+  visitors: {
+    value: FallbackVisitor,
+    document: {
+      objects: {
+        /**
+         * API Design Systems 2021-05-07 specification elements.
+         */
+        Main: {
+          $visitor: MainVisitor,
+          fixedFields: {
+            version: MainVersionVisitor,
+            info: {
+              $ref: '#/visitors/document/objects/Info'
+            },
+            principles: MainPrinciplesVisitor,
+            standards: MainStandardsVisitor,
+            scenarios: MainScenariosVisitor
+          }
+        },
+        Info: {
+          $visitor: InfoVisitor,
+          fixedFields: {
+            title: InfoTitleVisitor,
+            description: InfoDescriptionVisitor
+          }
+        },
+        Principle: {
+          $visitor: PrincipleVisitor,
+          fixedFields: {
+            name: PrincipleNameVisitor,
+            description: PrincipleDescriptionVisitor,
+            iri: PrincipleIriVisitor,
+            level: {
+              $ref: '#/visitors/document/objects/RequirementLevel'
+            }
+          }
+        },
+        Standard: {
+          $visitor: StandardVisitor,
+          fixedFields: {
+            name: StandardNameVisitor,
+            description: StandardDescriptionVisitor,
+            level: {
+              $ref: '#/visitors/document/objects/RequirementLevel'
+            },
+            iri: StandardIriVisitor
+          }
+        },
+        Scenario: {
+          $visitor: ScenarioVisitor,
+          fixedFields: {
+            description: ScenarioDescriptionVisitor,
+            when: {
+              $ref: '#/visitors/document/objects/StandardIdentifier'
+            },
+            then: ScenarioThenVisitor
+          }
+        },
+        Requirement: {
+          $visitor: RequirementVisitor,
+          fixedFields: {
+            subject: {
+              $ref: '#/visitors/document/objects/StandardIdentifier'
+            },
+            level: {
+              $ref: '#/visitors/document/objects/RequirementLevel'
+            },
+            values: RequirementValuesVisitor,
+            follows: RequirementFollowsVisitor
+          }
+        },
+        StandardIdentifier: StandardIdentifierVisitor,
+        RequirementLevel: RequirementLevelVisitor
+      }
+    }
+  }
+};
+export default specification;

package/es/refractor/toolbox.js

@@ -0,0 +1,17 @@
+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 { createNamespace, isStringElement } from '@swagger-api/apidom-core';
+import * as apiDesignSystemsPredicates from "../predicates.js";
+import apiDesignSystemNamespace from "../namespace.js";
+const createToolbox = () => {
+  const namespace = createNamespace(apiDesignSystemNamespace);
+  const predicates = _objectSpread(_objectSpread({}, apiDesignSystemsPredicates), {}, {
+    isStringElement
+  });
+  return {
+    predicates,
+    namespace
+  };
+};
+export default createToolbox;

package/es/refractor/visitors/FallbackVisitor.js

@@ -0,0 +1,18 @@
+import stampit from 'stampit';
+import { BREAK } from '@swagger-api/apidom-core';
+import Visitor from "./Visitor.js";
+/**
+ * This visitor is responsible for falling back to current traversed element
+ * Given AsyncApi2Visitor expects ObjectElement to be traversed. If
+ * different Element is provided FallBackVisitor is responsible to assigning
+ * this Element as current element.
+ */
+const FallbackVisitor = stampit(Visitor, {
+  methods: {
+    enter(element) {
+      this.element = element.clone();
+      return BREAK;
+    }
+  }
+});
+export default FallbackVisitor;

package/es/refractor/visitors/SpecificationVisitor.js

@@ -0,0 +1,69 @@
+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 { keyMap, getNodeType } from "../../traversal/visitor.js";
+import Visitor from "./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: {
+    specObj: null
+  },
+  // @ts-ignore
+  init({
+    specObj = this.specObj
+  }) {
+    this.specObj = specObj;
+  },
+  methods: {
+    retrievePassingOptions() {
+      return pick(['namespace', 'specObj'], 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(_objectSpread({
+        keyMap
+      }, options), {}, {
+        nodeTypeGetter: getNodeType
+      }));
+      return visitor.element;
+    }
+  }
+});
+export default SpecificationVisitor;

package/es/refractor/visitors/Visitor.js

@@ -0,0 +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'));
+      }
+    }
+  }
+});
+export default Visitor;

package/es/refractor/visitors/api-design-systems/info/DescriptionVisitor.js

@@ -0,0 +1,3 @@
+import FallbackVisitor from "../../FallbackVisitor.js";
+const DescriptionVisitor = FallbackVisitor;
+export default DescriptionVisitor;

package/es/refractor/visitors/api-design-systems/info/TitleVisitor.js

@@ -0,0 +1,3 @@
+import FallbackVisitor from "../../FallbackVisitor.js";
+const TitleVisitor = FallbackVisitor;
+export default TitleVisitor;

package/es/refractor/visitors/api-design-systems/info/index.js

@@ -0,0 +1,14 @@
+import stampit from 'stampit';
+import { always } from 'ramda';
+import InfoElement from "../../../../elements/Info.js";
+import FallbackVisitor from "../../FallbackVisitor.js";
+import FixedFieldsVisitor from "../../generics/FixedFieldsVisitor.js";
+const InfoVisitor = stampit(FixedFieldsVisitor, FallbackVisitor, {
+  props: {
+    specPath: always(['document', 'objects', 'Info'])
+  },
+  init() {
+    this.element = new InfoElement();
+  }
+});
+export default InfoVisitor;

package/es/refractor/visitors/api-design-systems/main/PrinciplesVisitor.js

@@ -0,0 +1,22 @@
+import stampit from 'stampit';
+import { ArrayElement, BREAK } from '@swagger-api/apidom-core';
+import FallbackVisitor from "../../FallbackVisitor.js";
+import SpecificationVisitor from "../../SpecificationVisitor.js";
+const PrinciplesVisitor = stampit(SpecificationVisitor, FallbackVisitor, {
+  init() {
+    this.element = new ArrayElement();
+    this.element.classes.push('main-principles');
+  },
+  methods: {
+    ArrayElement(arrayElement) {
+      arrayElement.forEach(item => {
+        const specPath = ['document', 'objects', 'Principle'];
+        const element = this.toRefractedElement(specPath, item);
+        this.element.push(element);
+      });
+      this.copyMetaAndAttributes(arrayElement, this.element);
+      return BREAK;
+    }
+  }
+});
+export default PrinciplesVisitor;

package/es/refractor/visitors/api-design-systems/main/ScenariosVisitor.js

@@ -0,0 +1,22 @@
+import stampit from 'stampit';
+import { ArrayElement, BREAK } from '@swagger-api/apidom-core';
+import FallbackVisitor from "../../FallbackVisitor.js";
+import SpecificationVisitor from "../../SpecificationVisitor.js";
+const ScenariosVisitor = stampit(SpecificationVisitor, FallbackVisitor, {
+  init() {
+    this.element = new ArrayElement();
+    this.element.classes.push('main-scenarios');
+  },
+  methods: {
+    ArrayElement(arrayElement) {
+      arrayElement.forEach(item => {
+        const specPath = ['document', 'objects', 'Scenario'];
+        const element = this.toRefractedElement(specPath, item);
+        this.element.push(element);
+      });
+      this.copyMetaAndAttributes(arrayElement, this.element);
+      return BREAK;
+    }
+  }
+});
+export default ScenariosVisitor;

package/es/refractor/visitors/api-design-systems/main/StandardsVisitor.js

@@ -0,0 +1,22 @@
+import stampit from 'stampit';
+import { ArrayElement, BREAK } from '@swagger-api/apidom-core';
+import FallbackVisitor from "../../FallbackVisitor.js";
+import SpecificationVisitor from "../../SpecificationVisitor.js";
+const StandardsVisitor = stampit(SpecificationVisitor, FallbackVisitor, {
+  init() {
+    this.element = new ArrayElement();
+    this.element.classes.push('main-standards');
+  },
+  methods: {
+    ArrayElement(arrayElement) {
+      arrayElement.forEach(item => {
+        const specPath = ['document', 'objects', 'Standard'];
+        const element = this.toRefractedElement(specPath, item);
+        this.element.push(element);
+      });
+      this.copyMetaAndAttributes(arrayElement, this.element);
+      return BREAK;
+    }
+  }
+});
+export default StandardsVisitor;

package/es/refractor/visitors/api-design-systems/main/VersionVisitor.js

@@ -0,0 +1,3 @@
+import FallbackVisitor from "../../FallbackVisitor.js";
+const VersionVisitor = FallbackVisitor;
+export default VersionVisitor;

package/es/refractor/visitors/api-design-systems/main/index.js

@@ -0,0 +1,14 @@
+import stampit from 'stampit';
+import { always } from 'ramda';
+import MainElement from "../../../../elements/Main.js";
+import FallbackVisitor from "../../FallbackVisitor.js";
+import FixedFieldsVisitor from "../../generics/FixedFieldsVisitor.js";
+const MainVisitor = stampit(FixedFieldsVisitor, FallbackVisitor, {
+  props: {
+    specPath: always(['document', 'objects', 'Main'])
+  },
+  init() {
+    this.element = new MainElement();
+  }
+});
+export default MainVisitor;