@speclynx/apidom-ns-openapi-2 4.0.2 → 4.0.3

package/src/refractor/visitors/open-api-2/reference/index.cjs

@@ -0,0 +1,29 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault").default;
+exports.__esModule = true;
+exports.default = void 0;
+var _ramda = require("ramda");
+var _apidomDatamodel = require("@speclynx/apidom-datamodel");
+var _Reference = _interopRequireDefault(require("../../../../elements/Reference.cjs"));
+var _bases = require("../bases.cjs");
+/**
+ * @public
+ */
+class ReferenceVisitor extends _bases.BaseFixedFieldsVisitor {
+  constructor(options) {
+    super(options);
+    this.element = new _Reference.default();
+    this.specPath = (0, _ramda.always)(['document', 'objects', 'Reference']);
+    this.canSupportSpecificationExtensions = false;
+  }
+  ObjectElement(path) {
+    _bases.BaseFixedFieldsVisitor.prototype.ObjectElement.call(this, path);
+
+    // mark this ReferenceElement with reference metadata
+    if ((0, _apidomDatamodel.isStringElement)(this.element.$ref)) {
+      this.element.classes.push('reference-element');
+    }
+  }
+}
+var _default = exports.default = ReferenceVisitor;

package/src/refractor/visitors/open-api-2/reference/index.mjs

@@ -0,0 +1,24 @@
+import { always } from 'ramda';
+import { isStringElement } from '@speclynx/apidom-datamodel';
+import ReferenceElement from "../../../../elements/Reference.mjs";
+import { BaseFixedFieldsVisitor } from "../bases.mjs";
+/**
+ * @public
+ */
+class ReferenceVisitor extends BaseFixedFieldsVisitor {
+  constructor(options) {
+    super(options);
+    this.element = new ReferenceElement();
+    this.specPath = always(['document', 'objects', 'Reference']);
+    this.canSupportSpecificationExtensions = false;
+  }
+  ObjectElement(path) {
+    BaseFixedFieldsVisitor.prototype.ObjectElement.call(this, path);
+
+    // mark this ReferenceElement with reference metadata
+    if (isStringElement(this.element.$ref)) {
+      this.element.classes.push('reference-element');
+    }
+  }
+}
+export default ReferenceVisitor;

package/src/refractor/visitors/open-api-2/reference/index.ts

@@ -0,0 +1,38 @@
+import { always } from 'ramda';
+import { ObjectElement, isStringElement } from '@speclynx/apidom-datamodel';
+import { Path } from '@speclynx/apidom-traverse';
+
+import ReferenceElement from '../../../../elements/Reference.ts';
+import { SpecPath } from '../../generics/FixedFieldsVisitor.ts';
+import { BaseFixedFieldsVisitor, BaseFixedFieldsVisitorOptions } from '../bases.ts';
+
+export type { BaseFixedFieldsVisitorOptions as ReferenceVisitorOptions };
+
+/**
+ * @public
+ */
+class ReferenceVisitor extends BaseFixedFieldsVisitor {
+  declare public readonly element: ReferenceElement;
+
+  declare protected readonly specPath: SpecPath<['document', 'objects', 'Reference']>;
+
+  declare protected readonly canSupportSpecificationExtensions: false;
+
+  constructor(options: BaseFixedFieldsVisitorOptions) {
+    super(options);
+    this.element = new ReferenceElement();
+    this.specPath = always(['document', 'objects', 'Reference']);
+    this.canSupportSpecificationExtensions = false;
+  }
+
+  ObjectElement(path: Path<ObjectElement>) {
+    BaseFixedFieldsVisitor.prototype.ObjectElement.call(this, path);
+
+    // mark this ReferenceElement with reference metadata
+    if (isStringElement(this.element.$ref)) {
+      this.element.classes.push('reference-element');
+    }
+  }
+}
+
+export default ReferenceVisitor;

package/src/refractor/visitors/open-api-2/response/index.cjs

@@ -0,0 +1,20 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault").default;
+exports.__esModule = true;
+exports.default = void 0;
+var _ramda = require("ramda");
+var _Response = _interopRequireDefault(require("../../../../elements/Response.cjs"));
+var _bases = require("../bases.cjs");
+/**
+ * @public
+ */
+class ResponseVisitor extends _bases.BaseFixedFieldsVisitor {
+  constructor(options) {
+    super(options);
+    this.element = new _Response.default();
+    this.specPath = (0, _ramda.always)(['document', 'objects', 'Response']);
+    this.canSupportSpecificationExtensions = true;
+  }
+}
+var _default = exports.default = ResponseVisitor;

package/src/refractor/visitors/open-api-2/response/index.mjs

@@ -0,0 +1,15 @@
+import { always } from 'ramda';
+import ResponseElement from "../../../../elements/Response.mjs";
+import { BaseFixedFieldsVisitor } from "../bases.mjs";
+/**
+ * @public
+ */
+class ResponseVisitor extends BaseFixedFieldsVisitor {
+  constructor(options) {
+    super(options);
+    this.element = new ResponseElement();
+    this.specPath = always(['document', 'objects', 'Response']);
+    this.canSupportSpecificationExtensions = true;
+  }
+}
+export default ResponseVisitor;

package/src/refractor/visitors/open-api-2/response/index.ts

@@ -0,0 +1,27 @@
+import { always } from 'ramda';
+
+import ResponseElement from '../../../../elements/Response.ts';
+import { SpecPath } from '../../generics/FixedFieldsVisitor.ts';
+import { BaseFixedFieldsVisitor, BaseFixedFieldsVisitorOptions } from '../bases.ts';
+
+export type { BaseFixedFieldsVisitorOptions as ResponseVisitorOptions };
+
+/**
+ * @public
+ */
+class ResponseVisitor extends BaseFixedFieldsVisitor {
+  declare public readonly element: ResponseElement;
+
+  declare protected readonly specPath: SpecPath<['document', 'objects', 'Response']>;
+
+  declare protected readonly canSupportSpecificationExtensions: true;
+
+  constructor(options: BaseFixedFieldsVisitorOptions) {
+    super(options);
+    this.element = new ResponseElement();
+    this.specPath = always(['document', 'objects', 'Response']);
+    this.canSupportSpecificationExtensions = true;
+  }
+}
+
+export default ResponseVisitor;

package/src/refractor/visitors/open-api-2/responses/DefaultVisitor.cjs

@@ -0,0 +1,36 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault").default;
+exports.__esModule = true;
+exports.default = void 0;
+var _ramda = require("ramda");
+var _predicates = require("../../../predicates.cjs");
+var _predicates2 = require("../../../../predicates.cjs");
+var _bases = require("../bases.cjs");
+var _AlternatingVisitor = _interopRequireDefault(require("../../generics/AlternatingVisitor.cjs"));
+/**
+ * @public
+ */
+class DefaultVisitor extends _bases.BaseAlternatingVisitor {
+  constructor(options) {
+    super(options);
+    this.alternator = [{
+      predicate: _predicates.isReferenceLikeElement,
+      specPath: ['document', 'objects', 'Reference']
+    }, {
+      predicate: _ramda.T,
+      specPath: ['document', 'objects', 'Response']
+    }];
+  }
+  ObjectElement(path) {
+    _AlternatingVisitor.default.prototype.enter.call(this, path);
+
+    // decorate ReferenceElement with type of referencing element
+    if ((0, _predicates2.isReferenceElement)(this.element)) {
+      this.element.meta.set('referenced-element', 'response');
+    } else if ((0, _predicates2.isResponseElement)(this.element)) {
+      this.element.meta.set('http-status-code', 'default');
+    }
+  }
+}
+var _default = exports.default = DefaultVisitor;

package/src/refractor/visitors/open-api-2/responses/DefaultVisitor.mjs

@@ -0,0 +1,31 @@
+import { T as stubTrue } from 'ramda';
+import { isReferenceLikeElement } from "../../../predicates.mjs";
+import { isReferenceElement, isResponseElement } from "../../../../predicates.mjs";
+import { BaseAlternatingVisitor } from "../bases.mjs";
+import AlternatingVisitor from "../../generics/AlternatingVisitor.mjs";
+/**
+ * @public
+ */
+class DefaultVisitor extends BaseAlternatingVisitor {
+  constructor(options) {
+    super(options);
+    this.alternator = [{
+      predicate: isReferenceLikeElement,
+      specPath: ['document', 'objects', 'Reference']
+    }, {
+      predicate: stubTrue,
+      specPath: ['document', 'objects', 'Response']
+    }];
+  }
+  ObjectElement(path) {
+    AlternatingVisitor.prototype.enter.call(this, path);
+
+    // decorate ReferenceElement with type of referencing element
+    if (isReferenceElement(this.element)) {
+      this.element.meta.set('referenced-element', 'response');
+    } else if (isResponseElement(this.element)) {
+      this.element.meta.set('http-status-code', 'default');
+    }
+  }
+}
+export default DefaultVisitor;

package/src/refractor/visitors/open-api-2/responses/DefaultVisitor.ts

@@ -0,0 +1,36 @@
+import { T as stubTrue } from 'ramda';
+import { ObjectElement } from '@speclynx/apidom-datamodel';
+import { Path } from '@speclynx/apidom-traverse';
+
+import { isReferenceLikeElement } from '../../../predicates.ts';
+import { isReferenceElement, isResponseElement } from '../../../../predicates.ts';
+import { BaseAlternatingVisitor, BaseAlternatingVisitorOptions } from '../bases.ts';
+import AlternatingVisitor from '../../generics/AlternatingVisitor.ts';
+
+export type { BaseAlternatingVisitorOptions as DefaultVisitorOptions };
+
+/**
+ * @public
+ */
+class DefaultVisitor extends BaseAlternatingVisitor {
+  constructor(options: BaseAlternatingVisitorOptions) {
+    super(options);
+    this.alternator = [
+      { predicate: isReferenceLikeElement, specPath: ['document', 'objects', 'Reference'] },
+      { predicate: stubTrue, specPath: ['document', 'objects', 'Response'] },
+    ];
+  }
+
+  ObjectElement(path: Path<ObjectElement>) {
+    AlternatingVisitor.prototype.enter.call(this, path);
+
+    // decorate ReferenceElement with type of referencing element
+    if (isReferenceElement(this.element)) {
+      this.element.meta.set('referenced-element', 'response');
+    } else if (isResponseElement(this.element)) {
+      this.element.meta.set('http-status-code', 'default');
+    }
+  }
+}
+
+export default DefaultVisitor;

package/src/refractor/visitors/open-api-2/responses/index.cjs

@@ -0,0 +1,45 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault").default;
+exports.__esModule = true;
+exports.default = void 0;
+var _ramda = require("ramda");
+var _apidomCore = require("@speclynx/apidom-core");
+var _Responses = _interopRequireDefault(require("../../../../elements/Responses.cjs"));
+var _predicates = require("../../../predicates.cjs");
+var _predicates2 = require("../../../../predicates.cjs");
+var _bases = require("../bases.cjs");
+/**
+ * @public
+ */
+class ResponsesVisitor extends _bases.BaseMixedFieldsVisitor {
+  constructor(options) {
+    super(options);
+    this.element = new _Responses.default();
+    this.specPathFixedFields = (0, _ramda.always)(['document', 'objects', 'Responses']);
+    this.canSupportSpecificationExtensions = true;
+    this.specPathPatternedFields = element => {
+      return (0, _predicates.isReferenceLikeElement)(element) ? ['document', 'objects', 'Reference'] : ['document', 'objects', 'Response'];
+    };
+    // @ts-ignore
+    this.fieldPatternPredicate = (0, _ramda.test)(new RegExp(`^(1XX|2XX|3XX|4XX|5XX|${(0, _ramda.range)(100, 600).join('|')})$`));
+  }
+  ObjectElement(path) {
+    _bases.BaseMixedFieldsVisitor.prototype.ObjectElement.call(this, path);
+
+    // decorate every ReferenceElement with metadata about their referencing type
+    // @ts-ignore
+    this.element.filter(_predicates2.isReferenceElement).forEach(referenceElement => {
+      referenceElement.meta.set('referenced-element', 'response');
+    });
+
+    // decorate every ResponseElement with metadata about their status code
+    // @ts-ignore
+    this.element.filter(_predicates2.isResponseElement).forEach((value, key) => {
+      const httpStatusCode = (0, _apidomCore.toValue)(key);
+      if (!this.fieldPatternPredicate(httpStatusCode)) return;
+      value.meta.set('http-status-code', httpStatusCode);
+    });
+  }
+}
+var _default = exports.default = ResponsesVisitor;

package/src/refractor/visitors/open-api-2/responses/index.mjs

@@ -0,0 +1,40 @@
+import { test, always, range } from 'ramda';
+import { toValue } from '@speclynx/apidom-core';
+import ResponsesElement from "../../../../elements/Responses.mjs";
+import { isReferenceLikeElement } from "../../../predicates.mjs";
+import { isReferenceElement, isResponseElement } from "../../../../predicates.mjs";
+import { BaseMixedFieldsVisitor } from "../bases.mjs";
+/**
+ * @public
+ */
+class ResponsesVisitor extends BaseMixedFieldsVisitor {
+  constructor(options) {
+    super(options);
+    this.element = new ResponsesElement();
+    this.specPathFixedFields = always(['document', 'objects', 'Responses']);
+    this.canSupportSpecificationExtensions = true;
+    this.specPathPatternedFields = element => {
+      return isReferenceLikeElement(element) ? ['document', 'objects', 'Reference'] : ['document', 'objects', 'Response'];
+    };
+    // @ts-ignore
+    this.fieldPatternPredicate = test(new RegExp(`^(1XX|2XX|3XX|4XX|5XX|${range(100, 600).join('|')})$`));
+  }
+  ObjectElement(path) {
+    BaseMixedFieldsVisitor.prototype.ObjectElement.call(this, path);
+
+    // decorate every ReferenceElement with metadata about their referencing type
+    // @ts-ignore
+    this.element.filter(isReferenceElement).forEach(referenceElement => {
+      referenceElement.meta.set('referenced-element', 'response');
+    });
+
+    // decorate every ResponseElement with metadata about their status code
+    // @ts-ignore
+    this.element.filter(isResponseElement).forEach((value, key) => {
+      const httpStatusCode = toValue(key);
+      if (!this.fieldPatternPredicate(httpStatusCode)) return;
+      value.meta.set('http-status-code', httpStatusCode);
+    });
+  }
+}
+export default ResponsesVisitor;

package/src/refractor/visitors/open-api-2/responses/index.ts

@@ -0,0 +1,64 @@
+import { test, always, range } from 'ramda';
+import { Element, ObjectElement, StringElement } from '@speclynx/apidom-datamodel';
+import { toValue } from '@speclynx/apidom-core';
+import { Path } from '@speclynx/apidom-traverse';
+
+import ReferenceElement from '../../../../elements/Reference.ts';
+import ResponsesElement from '../../../../elements/Responses.ts';
+import { SpecPath } from '../../generics/MixedFieldsVisitor.ts';
+import { isReferenceLikeElement } from '../../../predicates.ts';
+import { isReferenceElement, isResponseElement } from '../../../../predicates.ts';
+import { BaseMixedFieldsVisitor, BaseMixedFieldsVisitorOptions } from '../bases.ts';
+
+export type { BaseMixedFieldsVisitorOptions as ResponsesVisitorOptions };
+
+/**
+ * @public
+ */
+class ResponsesVisitor extends BaseMixedFieldsVisitor {
+  declare public readonly element: ResponsesElement;
+
+  declare protected readonly specPathFixedFields: SpecPath<['document', 'objects', 'Responses']>;
+
+  declare protected readonly canSupportSpecificationExtensions: true;
+
+  declare protected readonly specPathPatternedFields: SpecPath<
+    ['document', 'objects', 'Reference'] | ['document', 'objects', 'Response']
+  >;
+
+  constructor(options: BaseMixedFieldsVisitorOptions) {
+    super(options);
+    this.element = new ResponsesElement();
+    this.specPathFixedFields = always(['document', 'objects', 'Responses']);
+    this.canSupportSpecificationExtensions = true;
+    this.specPathPatternedFields = (element: unknown) => {
+      return isReferenceLikeElement(element)
+        ? ['document', 'objects', 'Reference']
+        : ['document', 'objects', 'Response'];
+    };
+    // @ts-ignore
+    this.fieldPatternPredicate = test(
+      new RegExp(`^(1XX|2XX|3XX|4XX|5XX|${range(100, 600).join('|')})$`),
+    );
+  }
+
+  ObjectElement(path: Path<ObjectElement>) {
+    BaseMixedFieldsVisitor.prototype.ObjectElement.call(this, path);
+
+    // decorate every ReferenceElement with metadata about their referencing type
+    // @ts-ignore
+    this.element.filter(isReferenceElement).forEach((referenceElement: ReferenceElement) => {
+      referenceElement.meta.set('referenced-element', 'response');
+    });
+
+    // decorate every ResponseElement with metadata about their status code
+    // @ts-ignore
+    this.element.filter(isResponseElement).forEach((value: Element, key: StringElement) => {
+      const httpStatusCode = toValue(key) as string;
+      if (!this.fieldPatternPredicate(httpStatusCode)) return;
+      value.meta.set('http-status-code', httpStatusCode);
+    });
+  }
+}
+
+export default ResponsesVisitor;

package/src/refractor/visitors/open-api-2/responses-definitions/index.cjs

@@ -0,0 +1,19 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault").default;
+exports.__esModule = true;
+exports.default = void 0;
+var _ramda = require("ramda");
+var _ResponsesDefinitions = _interopRequireDefault(require("../../../../elements/ResponsesDefinitions.cjs"));
+var _bases = require("../bases.cjs");
+/**
+ * @public
+ */
+class ResponsesDefinitionsVisitor extends _bases.BaseMapVisitor {
+  constructor(options) {
+    super(options);
+    this.element = new _ResponsesDefinitions.default();
+    this.specPath = (0, _ramda.always)(['document', 'objects', 'Response']);
+  }
+}
+var _default = exports.default = ResponsesDefinitionsVisitor;

package/src/refractor/visitors/open-api-2/responses-definitions/index.mjs

@@ -0,0 +1,14 @@
+import { always } from 'ramda';
+import ResponsesDefinitionsElement from "../../../../elements/ResponsesDefinitions.mjs";
+import { BaseMapVisitor } from "../bases.mjs";
+/**
+ * @public
+ */
+class ResponsesDefinitionsVisitor extends BaseMapVisitor {
+  constructor(options) {
+    super(options);
+    this.element = new ResponsesDefinitionsElement();
+    this.specPath = always(['document', 'objects', 'Response']);
+  }
+}
+export default ResponsesDefinitionsVisitor;

package/src/refractor/visitors/open-api-2/responses-definitions/index.ts

@@ -0,0 +1,24 @@
+import { always } from 'ramda';
+
+import ResponsesDefinitionsElement from '../../../../elements/ResponsesDefinitions.ts';
+import { SpecPath } from '../../generics/MapVisitor.ts';
+import { BaseMapVisitor, BaseMapVisitorOptions } from '../bases.ts';
+
+export type { BaseMapVisitorOptions as ResponsesDefinitionsVisitorOptions };
+
+/**
+ * @public
+ */
+class ResponsesDefinitionsVisitor extends BaseMapVisitor {
+  declare public readonly element: ResponsesDefinitionsElement;
+
+  declare protected readonly specPath: SpecPath<['document', 'objects', 'Response']>;
+
+  constructor(options: BaseMapVisitorOptions) {
+    super(options);
+    this.element = new ResponsesDefinitionsElement();
+    this.specPath = always(['document', 'objects', 'Response']);
+  }
+}
+
+export default ResponsesDefinitionsVisitor;

package/src/refractor/visitors/open-api-2/schema/AllOfVisitor.cjs

@@ -0,0 +1,24 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = exports.JSONSchemaAllOfVisitor = void 0;
+var _apidomNsJsonSchemaDraft = require("@speclynx/apidom-ns-json-schema-draft-4");
+/**
+ * @public
+ */
+const JSONSchemaAllOfVisitor = exports.JSONSchemaAllOfVisitor = _apidomNsJsonSchemaDraft.specificationObj.visitors.document.objects.JSONSchema.fixedFields.allOf;
+
+/**
+ * @public
+ */
+class AllOfVisitor extends JSONSchemaAllOfVisitor {
+  ArrayElement(path) {
+    JSONSchemaAllOfVisitor.prototype.ArrayElement.call(this, path);
+    this.element.filter(_apidomNsJsonSchemaDraft.isJSONReferenceElement)
+    // @ts-ignore
+    .forEach(referenceElement => {
+      referenceElement.meta.set('referenced-element', 'schema');
+    });
+  }
+}
+var _default = exports.default = AllOfVisitor;

package/src/refractor/visitors/open-api-2/schema/AllOfVisitor.mjs

@@ -0,0 +1,20 @@
+import { specificationObj as JSONSchemaDraft4Specification, isJSONReferenceElement } from '@speclynx/apidom-ns-json-schema-draft-4';
+/**
+ * @public
+ */
+export const JSONSchemaAllOfVisitor = JSONSchemaDraft4Specification.visitors.document.objects.JSONSchema.fixedFields.allOf;
+
+/**
+ * @public
+ */
+class AllOfVisitor extends JSONSchemaAllOfVisitor {
+  ArrayElement(path) {
+    JSONSchemaAllOfVisitor.prototype.ArrayElement.call(this, path);
+    this.element.filter(isJSONReferenceElement)
+    // @ts-ignore
+    .forEach(referenceElement => {
+      referenceElement.meta.set('referenced-element', 'schema');
+    });
+  }
+}
+export default AllOfVisitor;

package/src/refractor/visitors/open-api-2/schema/AllOfVisitor.ts

@@ -0,0 +1,35 @@
+import { ArrayElement } from '@speclynx/apidom-datamodel';
+import { Path } from '@speclynx/apidom-traverse';
+import {
+  specificationObj as JSONSchemaDraft4Specification,
+  isJSONReferenceElement,
+  JSONReferenceElement,
+  AllOfVisitorOptions,
+  AllOfVisitor as AllOfVisitorType,
+} from '@speclynx/apidom-ns-json-schema-draft-4';
+
+export type { AllOfVisitorOptions };
+
+/**
+ * @public
+ */
+export const JSONSchemaAllOfVisitor: typeof AllOfVisitorType =
+  JSONSchemaDraft4Specification.visitors.document.objects.JSONSchema.fixedFields.allOf;
+
+/**
+ * @public
+ */
+class AllOfVisitor extends JSONSchemaAllOfVisitor {
+  ArrayElement(path: Path<ArrayElement>) {
+    JSONSchemaAllOfVisitor.prototype.ArrayElement.call(this, path);
+
+    this.element
+      .filter(isJSONReferenceElement)
+      // @ts-ignore
+      .forEach((referenceElement: JSONReferenceElement) => {
+        referenceElement.meta.set('referenced-element', 'schema');
+      });
+  }
+}
+
+export default AllOfVisitor;

package/src/refractor/visitors/open-api-2/schema/ItemsVisitor.cjs

@@ -0,0 +1,26 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+var _apidomNsJsonSchemaDraft = require("@speclynx/apidom-ns-json-schema-draft-4");
+exports.JSONSchemaItemsVisitor = _apidomNsJsonSchemaDraft.ItemsVisitor;
+/**
+ * @public
+ */
+class ItemsVisitor extends _apidomNsJsonSchemaDraft.ItemsVisitor {
+  ObjectElement(path) {
+    _apidomNsJsonSchemaDraft.ItemsVisitor.prototype.ObjectElement.call(this, path);
+    if ((0, _apidomNsJsonSchemaDraft.isJSONReferenceElement)(this.element)) {
+      this.element.meta.set('referenced-element', 'schema');
+    }
+  }
+  ArrayElement(path) {
+    _apidomNsJsonSchemaDraft.ItemsVisitor.prototype.ArrayElement.call(this, path);
+    this.element.filter(_apidomNsJsonSchemaDraft.isJSONReferenceElement)
+    // @ts-ignore
+    .forEach(referenceElement => {
+      referenceElement.meta.set('referenced-element', 'schema');
+    });
+  }
+}
+var _default = exports.default = ItemsVisitor;

package/src/refractor/visitors/open-api-2/schema/ItemsVisitor.mjs

@@ -0,0 +1,23 @@
+import { isJSONReferenceElement, ItemsVisitor as JSONSchemaItemsVisitor } from '@speclynx/apidom-ns-json-schema-draft-4';
+export { JSONSchemaItemsVisitor };
+
+/**
+ * @public
+ */
+class ItemsVisitor extends JSONSchemaItemsVisitor {
+  ObjectElement(path) {
+    JSONSchemaItemsVisitor.prototype.ObjectElement.call(this, path);
+    if (isJSONReferenceElement(this.element)) {
+      this.element.meta.set('referenced-element', 'schema');
+    }
+  }
+  ArrayElement(path) {
+    JSONSchemaItemsVisitor.prototype.ArrayElement.call(this, path);
+    this.element.filter(isJSONReferenceElement)
+    // @ts-ignore
+    .forEach(referenceElement => {
+      referenceElement.meta.set('referenced-element', 'schema');
+    });
+  }
+}
+export default ItemsVisitor;

package/src/refractor/visitors/open-api-2/schema/ItemsVisitor.ts

@@ -0,0 +1,38 @@
+import { ArrayElement, ObjectElement } from '@speclynx/apidom-datamodel';
+import { Path } from '@speclynx/apidom-traverse';
+import {
+  JSONReferenceElement,
+  isJSONReferenceElement,
+  ItemsVisitorOptions,
+  ItemsVisitor as JSONSchemaItemsVisitor,
+} from '@speclynx/apidom-ns-json-schema-draft-4';
+
+export type { ItemsVisitorOptions };
+
+export { JSONSchemaItemsVisitor };
+
+/**
+ * @public
+ */
+class ItemsVisitor extends JSONSchemaItemsVisitor {
+  ObjectElement(path: Path<ObjectElement>) {
+    JSONSchemaItemsVisitor.prototype.ObjectElement.call(this, path);
+
+    if (isJSONReferenceElement(this.element)) {
+      this.element.meta.set('referenced-element', 'schema');
+    }
+  }
+
+  ArrayElement(path: Path<ArrayElement>) {
+    JSONSchemaItemsVisitor.prototype.ArrayElement.call(this, path);
+
+    this.element
+      .filter(isJSONReferenceElement)
+      // @ts-ignore
+      .forEach((referenceElement: JSONReferenceElement) => {
+        referenceElement.meta.set('referenced-element', 'schema');
+      });
+  }
+}
+
+export default ItemsVisitor;