@beinformed/ui 1.65.13 → 1.65.14

package/src/models/attributes/input-constraints/__tests__/NumberGroupingConstraint.spec.js

@@ -1,85 +0,0 @@
-import NumberGroupingConstraint from "../NumberGroupingConstraint";
-
-describe("numberGroupingConstraint", () => {
-  it("validates if grouping separator exists on correct place", () => {
-    const constraintMinimalFormat = new NumberGroupingConstraint(".", ",", "0");
-
-    expect(constraintMinimalFormat.hasValidation()).toBe(true);
-    expect(constraintMinimalFormat.validate("1000000")).toBe(true);
-    expect(constraintMinimalFormat.validate("1.00.00.00")).toBe(false);
-    expect(constraintMinimalFormat.validate("1.000.000")).toBe(true);
-    expect(constraintMinimalFormat.validate("1000000,00")).toBe(true);
-    expect(constraintMinimalFormat.validate("1000000.00")).toBe(false);
-    expect(constraintMinimalFormat.validate("1000.000,00")).toBe(false);
-    expect(constraintMinimalFormat.validate("1000,000.00")).toBe(false);
-    expect(constraintMinimalFormat.validate("1.000.000,00")).toBe(true);
-    expect(constraintMinimalFormat.validate("1,000,000.00")).toBe(false);
-    expect(constraintMinimalFormat.validate("1.00.000,00")).toBe(false);
-    expect(constraintMinimalFormat.validate("1,00,000.00")).toBe(false);
-
-    const onlyDecimal = new NumberGroupingConstraint(".", ",", "###.##");
-    expect(onlyDecimal.validate("1000000")).toBe(true);
-    expect(onlyDecimal.validate("1.00.00.00")).toBe(false);
-    expect(onlyDecimal.validate("1.000.000")).toBe(true);
-    expect(onlyDecimal.validate("1000000,00")).toBe(true);
-    expect(onlyDecimal.validate("1000000.00")).toBe(false);
-    expect(onlyDecimal.validate("1.000.000,00")).toBe(true);
-    expect(onlyDecimal.validate("1,000,000.00")).toBe(false);
-    expect(onlyDecimal.validate("1000.000,00")).toBe(false);
-    expect(onlyDecimal.validate("1000,000.00")).toBe(false);
-    expect(onlyDecimal.validate("1.00.000,00")).toBe(false);
-    expect(onlyDecimal.validate("1,00,000.00")).toBe(false);
-
-    const moneyFormat = new NumberGroupingConstraint(".", ",", "#,##0.00");
-    expect(moneyFormat.validate("1.000.000")).toBe(true);
-    expect(moneyFormat.validate("1.00.00.00")).toBe(false);
-    expect(moneyFormat.validate("1000000,00")).toBe(true);
-    expect(moneyFormat.validate("1000000.00")).toBe(false);
-    expect(moneyFormat.validate("1000.000,00")).toBe(false);
-    expect(moneyFormat.validate("1000,000.00")).toBe(false);
-    expect(moneyFormat.validate("1.000.000,00")).toBe(true);
-    expect(moneyFormat.validate("1,000,000.00")).toBe(false);
-    expect(moneyFormat.validate("1.00.000,00")).toBe(false);
-    expect(moneyFormat.validate("1,00,000.00")).toBe(false);
-
-    const constraintGroupingDot = new NumberGroupingConstraint(
-      ".",
-      ",",
-      "##,##.##",
-    );
-    expect(constraintGroupingDot.validate("1000000")).toBe(true);
-    expect(constraintGroupingDot.validate("1.00.00.00")).toBe(true);
-    expect(constraintGroupingDot.validate("1,00,00,00.00")).toBe(false);
-    expect(constraintGroupingDot.validate("1000000,00")).toBe(true);
-    expect(constraintGroupingDot.validate("1000000.00")).toBe(false);
-    expect(constraintGroupingDot.validate("1.000.000,00")).toBe(false);
-    expect(constraintGroupingDot.validate("1,000,000.00")).toBe(false);
-    expect(constraintGroupingDot.validate("1000.000,00")).toBe(false);
-    expect(constraintGroupingDot.validate("1000,000.00")).toBe(false);
-    expect(constraintGroupingDot.validate("1.00.000,00")).toBe(false);
-    expect(constraintGroupingDot.validate("1,00,000.00")).toBe(false);
-
-    const constraintGroupingComma = new NumberGroupingConstraint(
-      ",",
-      ".",
-      "##,##.##",
-    );
-    expect(constraintGroupingComma.validate("1000000")).toBe(true);
-    expect(constraintGroupingComma.validate("1.00.00.00")).toBe(true);
-    expect(constraintGroupingComma.validate("1,00,00,00.00")).toBe(true);
-    expect(constraintGroupingComma.validate("1000000,00")).toBe(false);
-    expect(constraintGroupingComma.validate("1000000.00")).toBe(true);
-    expect(constraintGroupingComma.validate("1.000.000,00")).toBe(false);
-    expect(constraintGroupingComma.validate("1,000,000.00")).toBe(false);
-    expect(constraintGroupingComma.validate("1000.000,00")).toBe(false);
-    expect(constraintGroupingComma.validate("1000,000.00")).toBe(false);
-    expect(constraintGroupingComma.validate("1.00.000,00")).toBe(false);
-    expect(constraintGroupingComma.validate("1,00,000.00")).toBe(false);
-
-    const constraintNoDecimal = new NumberGroupingConstraint("", "", "0");
-
-    expect(constraintNoDecimal.validate("1000000")).toBe(true);
-    expect(constraintNoDecimal.validate("1.000.000")).toBe(true);
-    expect(constraintNoDecimal.validate("1.000.000,00")).toBe(true);
-  });
-});

package/src/models/attributes/input-constraints/__tests__/PasswordConfirmConstraint.spec.js

@@ -1,21 +0,0 @@
-import PasswordConfirmConstraint from "../PasswordConfirmConstraint";
-
-describe("passwordConfirmConstraint", () => {
-  it("passwordConfirmConstraint checks", () => {
-    const constraint = new PasswordConfirmConstraint("12345", "Other password");
-
-    expect(constraint).toBeInstanceOf(PasswordConfirmConstraint);
-    expect(constraint.hasValidation()).toBe(true);
-
-    expect(constraint.id).toBe("Constraint.Password.ConfirmMismatch");
-    expect(constraint.otherPasswordLabel).toBe("Other password");
-    expect(constraint.otherPasswordValue).toBe("12345");
-    expect(typeof constraint.defaultMessage).toBe("string");
-    expect(constraint.parameters).toStrictEqual({
-      other: "Other password",
-    });
-
-    expect(constraint.validate("98765")).toBeFalsy();
-    expect(constraint.validate("12345")).toBeTruthy();
-  });
-});

package/src/models/attributes/input-constraints/__tests__/PasswordLowerAndUpperCaseConstraint.spec.js

@@ -1,14 +0,0 @@
-import PasswordLowerAndUpperCaseConstraint from "../PasswordLowerAndUpperCaseConstraint";
-
-describe("password constraints", () => {
-  it("passwordLowerAndUpperCaseConstraint", () => {
-    const constraint = new PasswordLowerAndUpperCaseConstraint();
-
-    expect(constraint.hasValidation()).toBe(true);
-    expect(constraint.validate("aB")).toBeTruthy();
-    expect(constraint.validate("")).toBeFalsy();
-    expect(constraint.validate("a")).toBeFalsy();
-    expect(constraint.validate("B")).toBeFalsy();
-    expect(constraint.validate("1")).toBeFalsy();
-  });
-});

package/src/models/attributes/input-constraints/__tests__/PasswordMinNumericCharactersConstraint.spec.js

@@ -1,11 +0,0 @@
-import PasswordMinNumericCharactersConstraint from "../PasswordMinNumericCharactersConstraint";
-
-describe("password constraints", () => {
-  it("passwordMinNumericCharactersConstraint", () => {
-    const constraint = new PasswordMinNumericCharactersConstraint(1);
-
-    expect(constraint.hasValidation()).toBe(true);
-    expect(constraint.validate("ABCD12345")).toBeTruthy();
-    expect(constraint.validate("ABCD")).toBeFalsy();
-  });
-});

package/src/models/attributes/input-constraints/__tests__/PasswordMinSpecialCharactersConstraint.spec.js

@@ -1,11 +0,0 @@
-import PasswordMinSpecialCharactersConstraint from "../PasswordMinSpecialCharactersConstraint";
-
-describe("password constraints", () => {
-  it("passwordMinSpecialCharactersConstraint", () => {
-    const constraint = new PasswordMinSpecialCharactersConstraint(1);
-
-    expect(constraint.hasValidation()).toBe(true);
-    expect(constraint.validate("Ab&")).toBeTruthy();
-    expect(constraint.validate("Ab")).toBeFalsy();
-  });
-});

package/src/models/attributes/input-constraints/__tests__/PasswordThreeConsecutiveCharactersNotAllowedConstraint.spec.js

@@ -1,22 +0,0 @@
-import PasswordThreeConsecutiveCharactersNotAllowedConstraint from "../PasswordThreeConsecutiveCharactersNotAllowedConstraint";
-
-describe("password constraints", () => {
-  it("passwordThreeConsecutiveCharactersNotAllowedConstraint", () => {
-    const constraint =
-      new PasswordThreeConsecutiveCharactersNotAllowedConstraint(1);
-
-    expect(constraint.hasValidation()).toBe(true);
-    expect(constraint.validate("ABACDEFGH")).toBeTruthy();
-    expect(constraint.validate("ABAAABBCCDDEEFFGGHHAA")).toBeFalsy();
-    expect(constraint.validate("")).toBeTruthy();
-  });
-
-  it("passwordThreeConsecutiveCharactersNotAllowedConstraint 3 concecutive chars", () => {
-    const constraint =
-      new PasswordThreeConsecutiveCharactersNotAllowedConstraint(3);
-
-    expect(constraint.validate("AAABBACDEFGH")).toBeTruthy();
-    expect(constraint.validate("ABAAAABBCCDDEEFFGGHHAA")).toBeFalsy();
-    expect(constraint.validate("")).toBeTruthy();
-  });
-});

package/src/models/attributes/input-constraints/__tests__/RegexConstraint.spec.js

@@ -1,42 +0,0 @@
-import RegexConstraint from "../RegexConstraint";
-
-describe("regexConstraint", () => {
-  it("regex checks", () => {
-    const constraint = new RegexConstraint({
-      regex: "^[a-z0-9_-]{6,18}$",
-      messageKey: "Password_regex_validation",
-    });
-
-    expect(constraint).toBeInstanceOf(RegexConstraint);
-    expect(constraint.hasValidation()).toBe(true);
-
-    expect(constraint.validate("myp4ssw0rd")).toBeTruthy();
-    expect(constraint.validate("mypa$$w0rd")).toBeFalsy();
-  });
-
-  it("zipcode", () => {
-    const constraint = new RegexConstraint({
-      messageKey: "Constraint.ZipCode.InvalidFormat",
-      defaultMessage: "Must be a valid Dutch ZIP code, e.g. 1234 AB",
-      regex: "[1-9]{1}[0-9]{3}[\\s]?[a-zA-Z]{2}",
-    });
-
-    expect(constraint.validate("AAAA AB")).toBeFalsy();
-    expect(constraint.validate("1234 AB")).toBeTruthy();
-    expect(constraint.validate("1234AB")).toBeTruthy();
-  });
-
-  it("email", () => {
-    const constraint = new RegexConstraint({
-      messageKey: "Constraint.Email.InvalidFormat",
-      defaultMessage: "Must be a valid e-mail address",
-      regex: new RegExp(
-        '^(([^<>()\\[\\]\\\\.,;:\\s@"]+(\\.[^<>()\\[\\]\\\\.,;:\\s@"]+)*)|(".+"))@((\\[[0-9]{1,3}\\.[0-9]{1,3}\\.[0-9]{1,3}\\.[0-9]{1,3}\\])|(([a-zA-Z\\-0-9]+\\.)+[a-zA-Z]{2,}))$',
-        "gi",
-      ),
-    });
-
-    expect(constraint.validate("invalid_email")).toBeFalsy();
-    expect(constraint.validate("first.last@example.com")).toBeTruthy();
-  });
-});

package/src/models/attributes/input-constraints/__tests__/StringLengthConstraint.spec.js

@@ -1,102 +0,0 @@
-import StringLengthConstraint from "../StringLengthConstraint";
-
-describe("stringLengthConstraint", () => {
-  it("min Length", () => {
-    const constraint = new StringLengthConstraint(5);
-
-    expect(constraint).toBeInstanceOf(StringLengthConstraint);
-    expect(constraint.hasValidation()).toBe(true);
-    expect(constraint.id).toBe("Constraint.InvalidLengthTooShort");
-    expect(constraint.validate("abcd")).toBeFalsy();
-    expect(constraint.validate("abcde")).toBeTruthy();
-    expect(constraint.validate("abcdef")).toBeTruthy();
-    expect(constraint.defaultMessage).toBe(
-      "The length of the value  must be larger than ${min-length}",
-    );
-    expect(constraint.parameters).toStrictEqual({ "min-length": 5 });
-
-    expect(() => {
-      constraint.isLongEnough(123);
-    }).toThrow(TypeError);
-
-    expect(() => {
-      new StringLengthConstraint(null, null).isLongEnough("test");
-    }).toThrow(Error);
-
-    expect(constraint.isMandatoryConstraint).toBe(false);
-  });
-
-  it("max Length", () => {
-    const constraint = new StringLengthConstraint(null, 5);
-
-    expect(constraint).toBeInstanceOf(StringLengthConstraint);
-    expect(constraint.hasValidation()).toBe(true);
-    expect(constraint.id).toBe("Constraint.InvalidLengthTooLong");
-    expect(constraint.validate("abcd")).toBeTruthy();
-    expect(constraint.validate("abcde")).toBeTruthy();
-    expect(constraint.validate("abcdef")).toBeFalsy();
-    expect(constraint.defaultMessage).toBe(
-      "The length of the value must be smaller than ${max-length}",
-    );
-    expect(constraint.parameters).toStrictEqual({ "max-length": 5 });
-
-    expect(() => {
-      constraint.isSmallEnough(123);
-    }).toThrow(TypeError);
-
-    expect(() => {
-      new StringLengthConstraint(null, null).isSmallEnough("test");
-    }).toThrow(Error);
-  });
-
-  it("exact Length", () => {
-    const constraint = new StringLengthConstraint(5, 5);
-
-    expect(constraint).toBeInstanceOf(StringLengthConstraint);
-    expect(constraint.hasValidation()).toBe(true);
-    expect(constraint.id).toBe("Constraint.InvalidLengthExact");
-    expect(constraint.validate("abcd")).toBeFalsy();
-    expect(constraint.validate("abcde")).toBeTruthy();
-    expect(constraint.validate("abcdef")).toBeFalsy();
-    expect(constraint.defaultMessage).toBe(
-      "Length must be precisely ${length} characters",
-    );
-    expect(constraint.parameters).toStrictEqual({
-      length: 5,
-    });
-
-    expect(() => {
-      constraint.isExactLength(123);
-    }).toThrow(TypeError);
-
-    expect(() => {
-      new StringLengthConstraint(null, null).isExactLength("test");
-    }).toThrow(Error);
-  });
-
-  it("between Length", () => {
-    const constraint = new StringLengthConstraint(4, 6);
-
-    expect(constraint).toBeInstanceOf(StringLengthConstraint);
-    expect(constraint.hasValidation()).toBe(true);
-    expect(constraint.id).toBe("Constraint.InvalidLengthBetween");
-    expect(constraint.validate("abc")).toBeFalsy();
-    expect(constraint.validate("abcde")).toBeTruthy();
-    expect(constraint.validate("abcdefg")).toBeFalsy();
-    expect(constraint.defaultMessage).toBe(
-      "Length must be between ${min-length} and ${max-length} characters",
-    );
-    expect(constraint.parameters).toStrictEqual({
-      "min-length": 4,
-      "max-length": 6,
-    });
-
-    expect(() => {
-      constraint.isBetween(123);
-    }).toThrow(TypeError);
-
-    expect(() => {
-      new StringLengthConstraint(null, null).isBetween("test");
-    }).toThrow(Error);
-  });
-});

package/src/models/attributes/input-constraints/__tests__/XMLConstraint.spec.js

@@ -1,15 +0,0 @@
-import XMLConstraint from "../XMLConstraint";
-
-describe("xMLConstraint", () => {
-  it("xML checks", () => {
-    const constraint = new XMLConstraint();
-
-    expect(constraint).toBeInstanceOf(XMLConstraint);
-
-    expect(constraint.hasValidation()).toBe(true);
-    expect(constraint.isValidXML("<invalid>text<invalid>")).toBeFalsy();
-    expect(constraint.isValidXML("<valid>text</valid>")).toBeTruthy();
-    expect(constraint.isValidXML("{ isJson: true }")).toBeFalsy();
-    expect(constraint.isValidXML()).toBeFalsy();
-  });
-});

package/src/models/attributes/layouthint-rules/BaseLayoutHintRule.js

@@ -1,74 +0,0 @@
-// @flow
-/* eslint-disable no-unused-vars */
-
-import { IllegalStateException } from "../../../exceptions";
-
-import type { ILayoutHintRule, AttributeType } from "../../types";
-import type AttributeCollection from "../AttributeCollection";
-import type AttributeModel from "../AttributeModel";
-
-/**
- * Abstract class for layout hint rules
- * @abstract
- */
-class BaseLayoutHintRule implements ILayoutHintRule {
-  /**
-   * Indicates if the rule implements the isApplicableForHint method
-   * @type {boolean}
-   * @default false
-   */
-  static checkHintApplicability: boolean = false;
-
-  /**
-   * Indicates if the rule instance is applicable for a specific attribute<br>
-   */
-  static isApplicableForAttribute(attribute: AttributeType): boolean {
-    return true;
-  }
-
-  /**
-   * Indicates if the rule instance is applicable for a specific hint<br>
-   * Is required when checkHintApplicability is true
-   * @abstract
-   */
-  static isApplicableForHint(hint: string): boolean {
-    throw new IllegalStateException(
-      `Missing isApplicableForHint implementation on layout hint rule`,
-    );
-  }
-
-  /**
-   * Initialize the rule when isApplicableForAttribute is true and checkHintApplicability is false
-   * @abstract
-   */
-  static initAttribute(attribute: AttributeType): ILayoutHintRule {
-    throw new IllegalStateException(
-      `Missing initAttribute implementation on layout hint rule`,
-    );
-  }
-
-  /**
-   * Initialize the rule when isApplicableForAttribute and isApplicableForHint are both true,
-   * it receives the hint. Allows a rule to be instantiated multiple times for an attribute,
-   * but once for each hint entry
-   * @abstract
-   */
-  static initHint(hint: string): ILayoutHintRule {
-    throw new IllegalStateException(
-      `Missing initHint implementation on layout hint rule`,
-    );
-  }
-
-  /**
-   * Abstract method, implements process of layout hint rule,
-   * use this to enhance the applicable attribute or the attribute collection
-   * @abstract
-   */
-  process(attribute: AttributeModel, attributes: AttributeCollection): void {
-    throw new IllegalStateException(
-      `Missing process implementation on layout hint rule`,
-    );
-  }
-}
-
-export default BaseLayoutHintRule;

package/src/models/attributes/layouthint-rules/DependentAttribute.js

@@ -1,246 +0,0 @@
-// @flow
-import BaseLayoutHintRule from "./BaseLayoutHintRule";
-
-import {
-  DEPENDENT_ATTRIBUTE_CONTROL,
-  DEPENDENT_ATTRIBUTE,
-} from "../../../constants";
-
-import ChoiceAttributeModel from "../ChoiceAttributeModel";
-import BooleanAttributeModel from "../BooleanAttributeModel";
-
-import { ConfigurationException } from "../../../exceptions";
-
-import type AttributeCollection from "../AttributeCollection";
-import type AttributeModel from "../AttributeModel";
-
-const EQUALS = "equals";
-const INCLUDES = "includes";
-const NOT_EQUALS = "notEquals";
-const NOT_INCLUDES = "notIncludes";
-const NOT_IS_EMPTY = "notIsEmpty";
-const IS_EMPTY = "isEmpty";
-
-const SHOW = "show";
-const HIDE = "hide";
-
-/**
- * Depending attributes hint logic
- */
-class DependentAttribute extends BaseLayoutHintRule {
-  _action: string;
-  _control: string;
-  _operator: string;
-  _options: Array<string>;
-
-  /**
-   */
-  static checkHintApplicability: boolean = true;
-
-  /**
-   */
-  static isApplicableForHint(hint: string): boolean {
-    const regex = new RegExp(
-      `^${DEPENDENT_ATTRIBUTE}\\s?(${SHOW}|${HIDE})`,
-      "i",
-    );
-
-    return regex.test(hint);
-  }
-
-  /**
-   * Used on initHint to create an instance of this rule
-   */
-  static getRuleInstance(): DependentAttribute {
-    return new DependentAttribute();
-  }
-
-  /**
-   */
-  static initHint(hint: string): any {
-    const rule = this.getRuleInstance();
-
-    const OPERATORS = `${EQUALS}|${INCLUDES}|${NOT_EQUALS}|${NOT_INCLUDES}|${NOT_IS_EMPTY}|${IS_EMPTY}`;
-    const regex = new RegExp(
-      `${DEPENDENT_ATTRIBUTE}\\s?(\\S*)\\swhen ${DEPENDENT_ATTRIBUTE_CONTROL}:\\s?(.*?)\\s*(${OPERATORS})\\s(.*)`,
-      "i",
-    );
-    const isEmpyNotIsEmptRegex = new RegExp(
-      `${DEPENDENT_ATTRIBUTE}\\s?(\\S*)\\swhen ${DEPENDENT_ATTRIBUTE_CONTROL}:\\s?(.*?)\\s*(${OPERATORS})`,
-      "i",
-    );
-
-    const result = hint.match(regex)
-      ? hint.match(regex)
-      : hint.match(isEmpyNotIsEmptRegex);
-
-    if (result) {
-      rule.action = result[1];
-      rule.control = result[2];
-      rule.operator = result[3];
-      rule.options = !result[4] ? "" : result[4];
-    } else {
-      throw new ConfigurationException(
-        `No dependent information found on layout hint: ${hint}`,
-      );
-    }
-
-    return rule;
-  }
-
-  /**
-   */
-  get action(): string {
-    return this._action;
-  }
-
-  /**
-   */
-  set action(action: string) {
-    this._action = action;
-  }
-
-  /**
-   */
-  get control(): string {
-    return this._control;
-  }
-
-  /**
-   */
-  set control(control: string) {
-    this._control = control;
-  }
-
-  /**
-   */
-  get operator(): string {
-    return this._operator;
-  }
-
-  /**
-   */
-  set operator(operator: string) {
-    this._operator = operator;
-  }
-
-  /**
-   */
-  get options(): Array<string> {
-    return this._options;
-  }
-
-  /**
-   */
-  set options(options: string): void {
-    this._options = options.split("|").map((option) => option.trim());
-  }
-
-  /**
-   */
-  processEqualsOptions(
-    controlAttribute: ChoiceAttributeModel | BooleanAttributeModel,
-  ): boolean {
-    if (
-      controlAttribute instanceof ChoiceAttributeModel ||
-      controlAttribute instanceof BooleanAttributeModel
-    ) {
-      return this.options.every((option) =>
-        controlAttribute.selected.includes(option),
-      );
-    }
-
-    throw new ConfigurationException(
-      "Dependent control in combination with equals operator must be a choice, string or number attribute",
-    );
-  }
-
-  /**
-   */
-  processIncludesOptions(
-    controlAttribute: ChoiceAttributeModel | BooleanAttributeModel,
-  ): boolean {
-    if (controlAttribute instanceof ChoiceAttributeModel) {
-      return this.options.some((option) =>
-        controlAttribute.selected.includes(option),
-      );
-    }
-
-    throw new ConfigurationException(
-      "Dependent control in combination with includes operator must be a choice attribute",
-    );
-  }
-
-  /**
-   */
-  handleOperator(
-    controlAttribute: ChoiceAttributeModel | BooleanAttributeModel,
-  ): boolean {
-    switch (this.operator) {
-      case EQUALS:
-        return this.processEqualsOptions(controlAttribute);
-      case INCLUDES:
-        return this.processIncludesOptions(controlAttribute);
-      case NOT_EQUALS:
-        return !this.processEqualsOptions(controlAttribute);
-      case NOT_INCLUDES:
-        return !this.processIncludesOptions(controlAttribute);
-      case NOT_IS_EMPTY:
-        return controlAttribute?.selected.length !== 0;
-      case IS_EMPTY:
-        return controlAttribute?.selected.length === 0;
-      default:
-        throw new ConfigurationException(
-          `Unsupported operator for dependent question: ${this.operator}`,
-        );
-    }
-  }
-
-  /**
-   */
-  getControlAttribute(
-    attributes: AttributeCollection,
-  ): ChoiceAttributeModel | BooleanAttributeModel | null {
-    const attribute = attributes.getAttributeByLayoutHint(
-      `${DEPENDENT_ATTRIBUTE_CONTROL}:${this.control}`,
-      `${DEPENDENT_ATTRIBUTE_CONTROL}: ${this.control}`,
-    );
-
-    if (
-      attribute instanceof ChoiceAttributeModel ||
-      attribute instanceof BooleanAttributeModel
-    ) {
-      return attribute;
-    }
-
-    return null;
-  }
-
-  /**
-   */
-  process(attribute: AttributeModel, attributes: AttributeCollection): void {
-    const controlAttribute = this.getControlAttribute(attributes);
-    if (!controlAttribute) {
-      return;
-    }
-
-    controlAttribute.processLayoutHintRules(attributes);
-    if (controlAttribute.isHidden) {
-      attribute.hide();
-      return;
-    }
-
-    const result = this.handleOperator(controlAttribute);
-    if (this.action === SHOW) {
-      attribute.isHidden = !result;
-    } else if (this.action === HIDE) {
-      attribute.isHidden = result;
-    } else {
-      throw new ConfigurationException(
-        `Unsupported action ${this.action} for dependent question on attribute: ${attribute.label}`,
-      );
-    }
-  }
-}
-
-export default DependentAttribute;