@speclynx/apidom-ns-openapi-3-0 4.0.2 → 4.0.3

package/src/refractor/visitors/generics/FixedFieldsVisitor.mjs

@@ -0,0 +1,68 @@
+import { isStringElement, MemberElement, cloneDeep } from '@speclynx/apidom-datamodel';
+import { toValue } from '@speclynx/apidom-core';
+import SpecificationVisitor from "../SpecificationVisitor.mjs";
+import { isOpenApiExtension } from "../../predicates.mjs";
+/**
+ * @public
+ */
+/**
+ * @public
+ */
+/**
+ * @public
+ */
+class FixedFieldsVisitor extends SpecificationVisitor {
+  specPath;
+  ignoredFields;
+  canSupportSpecificationExtensions = true;
+  specificationExtensionPredicate = isOpenApiExtension;
+  constructor({
+    specPath,
+    ignoredFields,
+    canSupportSpecificationExtensions,
+    specificationExtensionPredicate,
+    ...rest
+  }) {
+    super({
+      ...rest
+    });
+    this.specPath = specPath;
+    this.ignoredFields = ignoredFields || [];
+    if (typeof canSupportSpecificationExtensions === 'boolean') {
+      this.canSupportSpecificationExtensions = canSupportSpecificationExtensions;
+    }
+    if (typeof specificationExtensionPredicate === 'function') {
+      this.specificationExtensionPredicate = specificationExtensionPredicate;
+    }
+  }
+  ObjectElement(path) {
+    const objectElement = path.node;
+    const specPath = this.specPath(objectElement);
+    const fields = this.retrieveFixedFields(specPath);
+
+    // @ts-ignore
+    objectElement.forEach((value, key, memberElement) => {
+      const keyValue = toValue(key);
+      if (isStringElement(key) && fields.includes(keyValue) && !this.ignoredFields.includes(keyValue)) {
+        const fixedFieldElement = this.toRefractedElement([...specPath, 'fixedFields', keyValue], value);
+        const newMemberElement = new MemberElement(this.consume ? key : cloneDeep(key), fixedFieldElement);
+        this.copyMetaAndAttributes(memberElement, newMemberElement);
+        this.element.content.push(newMemberElement);
+        // consume: release processed generic subtree
+        if (this.consume && this.consumeSafe && !memberElement.isFrozen) memberElement.value = undefined;
+      } else if (this.canSupportSpecificationExtensions && this.specificationExtensionPredicate(memberElement)) {
+        const extensionElement = this.toRefractedElement(['document', 'extension'], memberElement);
+        this.element.content.push(extensionElement);
+        // consume: release processed generic subtree
+        if (this.consume && this.consumeSafe && !memberElement.isFrozen) {
+          memberElement.value = undefined;
+        }
+      } else if (!this.ignoredFields.includes(keyValue)) {
+        this.element.content.push(this.consume ? memberElement : cloneDeep(memberElement));
+      }
+    });
+    this.copyMetaAndAttributes(objectElement, this.element);
+    path.stop();
+  }
+}
+export default FixedFieldsVisitor;

package/src/refractor/visitors/generics/FixedFieldsVisitor.ts

@@ -0,0 +1,110 @@
+import {
+  isStringElement,
+  MemberElement,
+  Element,
+  ObjectElement,
+  cloneDeep,
+} from '@speclynx/apidom-datamodel';
+import { toValue } from '@speclynx/apidom-core';
+import { Path } from '@speclynx/apidom-traverse';
+
+import SpecificationVisitor, { SpecificationVisitorOptions } from '../SpecificationVisitor.ts';
+import { isOpenApiExtension } from '../../predicates.ts';
+
+/**
+ * @public
+ */
+export type SpecPath<T = string[]> = (element: unknown) => T;
+
+/**
+ * @public
+ */
+export interface FixedFieldsVisitorOptions extends SpecificationVisitorOptions {
+  readonly specPath: SpecPath;
+  readonly ignoredFields?: string[];
+  readonly canSupportSpecificationExtensions?: boolean;
+  readonly specificationExtensionPredicate?: typeof isOpenApiExtension;
+}
+
+/**
+ * @public
+ */
+class FixedFieldsVisitor extends SpecificationVisitor {
+  protected specPath: SpecPath;
+
+  protected ignoredFields: string[];
+
+  protected canSupportSpecificationExtensions: boolean = true;
+
+  protected specificationExtensionPredicate = isOpenApiExtension;
+
+  constructor({
+    specPath,
+    ignoredFields,
+    canSupportSpecificationExtensions,
+    specificationExtensionPredicate,
+    ...rest
+  }: FixedFieldsVisitorOptions) {
+    super({ ...rest });
+    this.specPath = specPath;
+    this.ignoredFields = ignoredFields || [];
+
+    if (typeof canSupportSpecificationExtensions === 'boolean') {
+      this.canSupportSpecificationExtensions = canSupportSpecificationExtensions;
+    }
+
+    if (typeof specificationExtensionPredicate === 'function') {
+      this.specificationExtensionPredicate = specificationExtensionPredicate;
+    }
+  }
+
+  ObjectElement(path: Path<ObjectElement>) {
+    const objectElement = path.node;
+    const specPath = this.specPath(objectElement);
+    const fields = this.retrieveFixedFields(specPath);
+
+    // @ts-ignore
+    objectElement.forEach((value: Element, key: Element, memberElement: MemberElement) => {
+      const keyValue = toValue(key) as string;
+      if (
+        isStringElement(key) &&
+        fields.includes(keyValue) &&
+        !this.ignoredFields.includes(keyValue)
+      ) {
+        const fixedFieldElement = this.toRefractedElement(
+          [...specPath, 'fixedFields', keyValue],
+          value,
+        );
+        const newMemberElement = new MemberElement(
+          this.consume ? key : cloneDeep(key),
+          fixedFieldElement,
+        );
+        this.copyMetaAndAttributes(memberElement, newMemberElement);
+        (this.element.content as Element[]).push(newMemberElement);
+        // consume: release processed generic subtree
+        if (this.consume && this.consumeSafe && !memberElement.isFrozen)
+          memberElement.value = undefined;
+      } else if (
+        this.canSupportSpecificationExtensions &&
+        this.specificationExtensionPredicate(memberElement)
+      ) {
+        const extensionElement = this.toRefractedElement(['document', 'extension'], memberElement);
+        (this.element.content as Element[]).push(extensionElement);
+        // consume: release processed generic subtree
+        if (this.consume && this.consumeSafe && !memberElement.isFrozen) {
+          memberElement.value = undefined;
+        }
+      } else if (!this.ignoredFields.includes(keyValue)) {
+        (this.element.content as Element[]).push(
+          this.consume ? memberElement : cloneDeep(memberElement),
+        );
+      }
+    });
+
+    this.copyMetaAndAttributes(objectElement, this.element);
+
+    path.stop();
+  }
+}
+
+export default FixedFieldsVisitor;

package/src/refractor/visitors/generics/MapVisitor.cjs

@@ -0,0 +1,21 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault").default;
+exports.__esModule = true;
+exports.default = void 0;
+var _ramdaAdjunct = require("ramda-adjunct");
+var _PatternedFieldsVisitor = _interopRequireDefault(require("./PatternedFieldsVisitor.cjs"));
+/**
+ * @public
+ */
+
+/**
+ * @public
+ */
+class MapVisitor extends _PatternedFieldsVisitor.default {
+  constructor(options) {
+    super(options);
+    this.fieldPatternPredicate = _ramdaAdjunct.isNonEmptyString;
+  }
+}
+var _default = exports.default = MapVisitor;

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

@@ -0,0 +1,15 @@
+import { isNonEmptyString } from 'ramda-adjunct';
+import PatternedFieldsVisitor from "./PatternedFieldsVisitor.mjs";
+/**
+ * @public
+ */
+/**
+ * @public
+ */
+class MapVisitor extends PatternedFieldsVisitor {
+  constructor(options) {
+    super(options);
+    this.fieldPatternPredicate = isNonEmptyString;
+  }
+}
+export default MapVisitor;

package/src/refractor/visitors/generics/MapVisitor.ts

@@ -0,0 +1,25 @@
+import { isNonEmptyString } from 'ramda-adjunct';
+
+import PatternedFieldsVisitor, {
+  PatternedFieldsVisitorOptions,
+  SpecPath,
+} from './PatternedFieldsVisitor.ts';
+
+export type { SpecPath };
+
+/**
+ * @public
+ */
+export interface MapVisitorOptions extends PatternedFieldsVisitorOptions {}
+
+/**
+ * @public
+ */
+class MapVisitor extends PatternedFieldsVisitor {
+  constructor(options: MapVisitorOptions) {
+    super(options);
+    this.fieldPatternPredicate = isNonEmptyString;
+  }
+}
+
+export default MapVisitor;

package/src/refractor/visitors/generics/MixedFieldsVisitor.cjs

@@ -0,0 +1,67 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault").default;
+exports.__esModule = true;
+exports.default = exports.MixedFieldsVisitorBase = void 0;
+var _tsMixer = require("ts-mixer");
+var _ramda = require("ramda");
+var _apidomCore = require("@speclynx/apidom-core");
+var _FixedFieldsVisitor = _interopRequireDefault(require("./FixedFieldsVisitor.cjs"));
+var _PatternedFieldsVisitor = _interopRequireDefault(require("./PatternedFieldsVisitor.cjs"));
+/**
+ * @public
+ */
+
+/**
+ * Base class for MixedFieldsVisitor combining FixedFieldsVisitor and PatternedFieldsVisitor.
+ * @public
+ */
+const MixedFieldsVisitorBase = exports.MixedFieldsVisitorBase = (0, _tsMixer.Mixin)(_FixedFieldsVisitor.default, _PatternedFieldsVisitor.default);
+
+/**
+ * @public
+ */
+class MixedFieldsVisitor extends MixedFieldsVisitorBase {
+  specPathFixedFields;
+  specPathPatternedFields;
+  constructor({
+    specPathFixedFields,
+    specPathPatternedFields,
+    ...rest
+  }) {
+    super({
+      ...rest
+    });
+    this.specPathFixedFields = specPathFixedFields;
+    this.specPathPatternedFields = specPathPatternedFields;
+  }
+  ObjectElement(path) {
+    const objectElement = path.node;
+    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, ...(0, _ramda.difference)(objectElement.keys(), fixedFields)];
+      _FixedFieldsVisitor.default.prototype.ObjectElement.call(this, path);
+      this.specPath = this.specPathPatternedFields;
+      this.ignoredFields = fixedFields;
+      _PatternedFieldsVisitor.default.prototype.ObjectElement.call(this, path);
+
+      // reorder this.element members by original objectElement keys
+      const objectElementKeys = objectElement.keys();
+      this.element.content.sort((a, b) => {
+        return objectElementKeys.indexOf((0, _apidomCore.toValue)(a.key)) - objectElementKeys.indexOf((0, _apidomCore.toValue)(b.key));
+      });
+    } catch (e) {
+      this.specPath = specPath;
+      throw e;
+    }
+    path.stop();
+  }
+}
+var _default = exports.default = MixedFieldsVisitor;

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

@@ -0,0 +1,61 @@
+import { Mixin } from 'ts-mixer';
+import { difference } from 'ramda';
+import { toValue } from '@speclynx/apidom-core';
+import FixedFieldsVisitor from "./FixedFieldsVisitor.mjs";
+import PatternedFieldsVisitor from "./PatternedFieldsVisitor.mjs";
+/**
+ * @public
+ */
+/**
+ * Base class for MixedFieldsVisitor combining FixedFieldsVisitor and PatternedFieldsVisitor.
+ * @public
+ */
+export const MixedFieldsVisitorBase = Mixin(FixedFieldsVisitor, PatternedFieldsVisitor);
+
+/**
+ * @public
+ */
+class MixedFieldsVisitor extends MixedFieldsVisitorBase {
+  specPathFixedFields;
+  specPathPatternedFields;
+  constructor({
+    specPathFixedFields,
+    specPathPatternedFields,
+    ...rest
+  }) {
+    super({
+      ...rest
+    });
+    this.specPathFixedFields = specPathFixedFields;
+    this.specPathPatternedFields = specPathPatternedFields;
+  }
+  ObjectElement(path) {
+    const objectElement = path.node;
+    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, path);
+      this.specPath = this.specPathPatternedFields;
+      this.ignoredFields = fixedFields;
+      PatternedFieldsVisitor.prototype.ObjectElement.call(this, path);
+
+      // reorder this.element members by original objectElement keys
+      const objectElementKeys = objectElement.keys();
+      this.element.content.sort((a, b) => {
+        return objectElementKeys.indexOf(toValue(a.key)) - objectElementKeys.indexOf(toValue(b.key));
+      });
+    } catch (e) {
+      this.specPath = specPath;
+      throw e;
+    }
+    path.stop();
+  }
+}
+export default MixedFieldsVisitor;

package/src/refractor/visitors/generics/MixedFieldsVisitor.ts

@@ -0,0 +1,77 @@
+import { Mixin } from 'ts-mixer';
+import { difference } from 'ramda';
+import { ObjectElement, MemberElement, Element } from '@speclynx/apidom-datamodel';
+import { toValue } from '@speclynx/apidom-core';
+import { Path } from '@speclynx/apidom-traverse';
+
+import FixedFieldsVisitor, { SpecPath } from './FixedFieldsVisitor.ts';
+import PatternedFieldsVisitor, { PatternedFieldsVisitorOptions } from './PatternedFieldsVisitor.ts';
+
+export type { SpecPath };
+
+/**
+ * @public
+ */
+export interface MixedFieldsVisitorOptions extends PatternedFieldsVisitorOptions {
+  readonly specPathFixedFields: SpecPath;
+  readonly specPathPatternedFields: SpecPath;
+}
+
+/**
+ * Base class for MixedFieldsVisitor combining FixedFieldsVisitor and PatternedFieldsVisitor.
+ * @public
+ */
+export const MixedFieldsVisitorBase = Mixin(FixedFieldsVisitor, PatternedFieldsVisitor);
+
+/**
+ * @public
+ */
+class MixedFieldsVisitor extends MixedFieldsVisitorBase {
+  protected readonly specPathFixedFields: SpecPath;
+
+  protected readonly specPathPatternedFields: SpecPath;
+
+  constructor({
+    specPathFixedFields,
+    specPathPatternedFields,
+    ...rest
+  }: MixedFieldsVisitorOptions) {
+    super({ ...rest });
+    this.specPathFixedFields = specPathFixedFields;
+    this.specPathPatternedFields = specPathPatternedFields;
+  }
+
+  ObjectElement(path: Path<ObjectElement>) {
+    const objectElement = path.node;
+    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, path);
+
+      this.specPath = this.specPathPatternedFields;
+      this.ignoredFields = fixedFields;
+      PatternedFieldsVisitor.prototype.ObjectElement.call(this, path);
+
+      // reorder this.element members by original objectElement keys
+      const objectElementKeys = objectElement.keys() as string[];
+      (this.element.content as Element[]).sort((a: unknown, b: unknown) => {
+        return (
+          objectElementKeys.indexOf(toValue((a as MemberElement).key) as string) -
+          objectElementKeys.indexOf(toValue((b as MemberElement).key) as string)
+        );
+      });
+    } catch (e) {
+      this.specPath = specPath;
+      throw e;
+    }
+
+    path.stop();
+  }
+}
+
+export default MixedFieldsVisitor;

package/src/refractor/visitors/generics/PatternedFieldsVisitor.cjs

@@ -0,0 +1,72 @@
+"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 _apidomCore = require("@speclynx/apidom-core");
+var _SpecificationVisitor = _interopRequireDefault(require("../SpecificationVisitor.cjs"));
+var _predicates = require("../../predicates.cjs");
+/**
+ * @public
+ */
+
+/**
+ * @public
+ */
+class PatternedFieldsVisitor extends _SpecificationVisitor.default {
+  specPath;
+  ignoredFields;
+  fieldPatternPredicate = _ramda.F;
+  canSupportSpecificationExtensions = false;
+  specificationExtensionPredicate = _predicates.isOpenApiExtension;
+  constructor({
+    specPath,
+    ignoredFields,
+    fieldPatternPredicate,
+    canSupportSpecificationExtensions,
+    specificationExtensionPredicate,
+    ...rest
+  }) {
+    super({
+      ...rest
+    });
+    this.specPath = specPath;
+    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(path) {
+    const objectElement = path.node;
+    // @ts-ignore
+    objectElement.forEach((value, key, memberElement) => {
+      const keyValue = (0, _apidomCore.toValue)(key);
+      if (this.canSupportSpecificationExtensions && this.specificationExtensionPredicate(memberElement)) {
+        const extensionElement = this.toRefractedElement(['document', 'extension'], memberElement);
+        this.element.content.push(extensionElement);
+      } else if (!this.ignoredFields.includes(keyValue) && this.fieldPatternPredicate(keyValue)) {
+        const specPath = this.specPath(value);
+        const patternedFieldElement = this.toRefractedElement(specPath, value);
+        const newMemberElement = new _apidomDatamodel.MemberElement(this.consume ? key : (0, _apidomDatamodel.cloneDeep)(key), patternedFieldElement);
+        this.copyMetaAndAttributes(memberElement, newMemberElement);
+        newMemberElement.classes.push('patterned-field');
+        this.element.content.push(newMemberElement);
+        // consume: release processed generic subtree
+        if (this.consume && this.consumeSafe && !memberElement.isFrozen) memberElement.value = undefined;
+      } else if (!this.ignoredFields.includes(keyValue)) {
+        this.element.content.push(this.consume ? memberElement : (0, _apidomDatamodel.cloneDeep)(memberElement));
+      }
+    });
+    this.copyMetaAndAttributes(objectElement, this.element);
+    path.stop();
+  }
+}
+var _default = exports.default = PatternedFieldsVisitor;

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

@@ -0,0 +1,66 @@
+import { F as stubFalse } from 'ramda';
+import { MemberElement, cloneDeep } from '@speclynx/apidom-datamodel';
+import { toValue } from '@speclynx/apidom-core';
+import SpecificationVisitor from "../SpecificationVisitor.mjs";
+import { isOpenApiExtension } from "../../predicates.mjs";
+/**
+ * @public
+ */
+/**
+ * @public
+ */
+class PatternedFieldsVisitor extends SpecificationVisitor {
+  specPath;
+  ignoredFields;
+  fieldPatternPredicate = stubFalse;
+  canSupportSpecificationExtensions = false;
+  specificationExtensionPredicate = isOpenApiExtension;
+  constructor({
+    specPath,
+    ignoredFields,
+    fieldPatternPredicate,
+    canSupportSpecificationExtensions,
+    specificationExtensionPredicate,
+    ...rest
+  }) {
+    super({
+      ...rest
+    });
+    this.specPath = specPath;
+    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(path) {
+    const objectElement = path.node;
+    // @ts-ignore
+    objectElement.forEach((value, key, memberElement) => {
+      const keyValue = toValue(key);
+      if (this.canSupportSpecificationExtensions && this.specificationExtensionPredicate(memberElement)) {
+        const extensionElement = this.toRefractedElement(['document', 'extension'], memberElement);
+        this.element.content.push(extensionElement);
+      } else if (!this.ignoredFields.includes(keyValue) && this.fieldPatternPredicate(keyValue)) {
+        const specPath = this.specPath(value);
+        const patternedFieldElement = this.toRefractedElement(specPath, value);
+        const newMemberElement = new MemberElement(this.consume ? key : cloneDeep(key), patternedFieldElement);
+        this.copyMetaAndAttributes(memberElement, newMemberElement);
+        newMemberElement.classes.push('patterned-field');
+        this.element.content.push(newMemberElement);
+        // consume: release processed generic subtree
+        if (this.consume && this.consumeSafe && !memberElement.isFrozen) memberElement.value = undefined;
+      } else if (!this.ignoredFields.includes(keyValue)) {
+        this.element.content.push(this.consume ? memberElement : cloneDeep(memberElement));
+      }
+    });
+    this.copyMetaAndAttributes(objectElement, this.element);
+    path.stop();
+  }
+}
+export default PatternedFieldsVisitor;

package/src/refractor/visitors/generics/PatternedFieldsVisitor.ts

@@ -0,0 +1,99 @@
+import { F as stubFalse } from 'ramda';
+import { ObjectElement, Element, MemberElement, cloneDeep } from '@speclynx/apidom-datamodel';
+import { toValue } from '@speclynx/apidom-core';
+import { Path } from '@speclynx/apidom-traverse';
+
+import SpecificationVisitor, { SpecificationVisitorOptions } from '../SpecificationVisitor.ts';
+import type { SpecPath } from './FixedFieldsVisitor.ts';
+import { isOpenApiExtension } from '../../predicates.ts';
+
+export type { SpecPath };
+
+/**
+ * @public
+ */
+export interface PatternedFieldsVisitorOptions extends SpecificationVisitorOptions {
+  readonly specPath: SpecPath;
+  readonly ignoredFields?: string[];
+  readonly fieldPatternPredicate?: (...args: unknown[]) => boolean;
+  readonly canSupportSpecificationExtensions?: boolean;
+  readonly specificationExtensionPredicate?: typeof isOpenApiExtension;
+}
+
+/**
+ * @public
+ */
+class PatternedFieldsVisitor extends SpecificationVisitor {
+  protected specPath: SpecPath;
+
+  protected ignoredFields: string[];
+
+  protected fieldPatternPredicate: (value: unknown) => boolean = stubFalse;
+
+  protected canSupportSpecificationExtensions: boolean = false;
+
+  protected specificationExtensionPredicate = isOpenApiExtension;
+
+  constructor({
+    specPath,
+    ignoredFields,
+    fieldPatternPredicate,
+    canSupportSpecificationExtensions,
+    specificationExtensionPredicate,
+    ...rest
+  }: PatternedFieldsVisitorOptions) {
+    super({ ...rest });
+    this.specPath = specPath;
+    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(path: Path<ObjectElement>) {
+    const objectElement = path.node;
+    // @ts-ignore
+    objectElement.forEach((value: Element, key: Element, memberElement: MemberElement) => {
+      const keyValue = toValue(key) as string;
+      if (
+        this.canSupportSpecificationExtensions &&
+        this.specificationExtensionPredicate(memberElement)
+      ) {
+        const extensionElement = this.toRefractedElement(['document', 'extension'], memberElement);
+        (this.element.content as Element[]).push(extensionElement);
+      } else if (!this.ignoredFields.includes(keyValue) && this.fieldPatternPredicate(keyValue)) {
+        const specPath = this.specPath(value);
+        const patternedFieldElement = this.toRefractedElement(specPath, value);
+        const newMemberElement = new MemberElement(
+          this.consume ? key : cloneDeep(key),
+          patternedFieldElement,
+        );
+        this.copyMetaAndAttributes(memberElement, newMemberElement);
+        newMemberElement.classes.push('patterned-field');
+        (this.element.content as Element[]).push(newMemberElement);
+        // consume: release processed generic subtree
+        if (this.consume && this.consumeSafe && !memberElement.isFrozen)
+          memberElement.value = undefined;
+      } else if (!this.ignoredFields.includes(keyValue)) {
+        (this.element.content as Element[]).push(
+          this.consume ? memberElement : cloneDeep(memberElement),
+        );
+      }
+    });
+
+    this.copyMetaAndAttributes(objectElement, this.element);
+
+    path.stop();
+  }
+}
+
+export default PatternedFieldsVisitor;