@beinformed/ui 1.65.12 → 1.65.14

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

@@ -1,101 +0,0 @@
-// @flow
-import BaseCollection from "../../base/BaseCollection";
-
-import BaseLayoutHintRule from "./BaseLayoutHintRule";
-
-import DependentAttribute from "./DependentAttribute";
-import RemainingTotalUploadSize from "./RemainingTotalUploadSize";
-
-import { IllegalReturnException } from "../../../exceptions";
-
-import type AttributeCollection from "../AttributeCollection";
-import type { AttributeType, ILayoutHintRule } from "../../types";
-import type AttributeModel from "../AttributeModel";
-
-/**
- * Array of available layout hint rules
- * @private
- */
-let layoutHintRules: Array<Class<BaseLayoutHintRule>> = [
-  DependentAttribute,
-  RemainingTotalUploadSize,
-];
-
-/**
- * Add custom layout hint rules
- */
-export const addLayoutHintRule = (rule: Class<BaseLayoutHintRule>) => {
-  layoutHintRules.push(rule);
-};
-
-type LayoutHintRulesUpdater = (
-  rules: Array<Class<BaseLayoutHintRule>>,
-) => Array<Class<BaseLayoutHintRule>>;
-
-/**
- * Update existing array of layout hint rules, use this to update or remove standard rules
- *
- * @example
- * // remove RemainingTotalUploadSize rule
- * updateLayoutHintRules((rules) => {
- *   return rules.filter(rule => rule !== RemainingTotalUploadSize));
- * });
- */
-export const updateLayoutHintRules = (updater: LayoutHintRulesUpdater) => {
-  const newRules = updater(layoutHintRules);
-  if (Array.isArray(newRules)) {
-    layoutHintRules = newRules;
-  } else {
-    throw new IllegalReturnException(
-      "Result of updater of updateLayoutHintRules is not an array",
-    );
-  }
-};
-
-/**
- * Collection of layout hint rules
- */
-class LayoutHintRuleCollection extends BaseCollection<ILayoutHintRule> {
-  /**
-   * Retrieve all rules available in the collection
-   */
-  get allRules(): Array<Class<BaseLayoutHintRule>> {
-    return layoutHintRules;
-  }
-
-  /**
-   * Set layout hint rules on the applicable attributes
-   */
-  static setLayoutHintRules<T: AttributeType>(attribute: T): T {
-    const rules = new LayoutHintRuleCollection();
-
-    layoutHintRules.forEach((rule) => {
-      if (rule.isApplicableForAttribute(attribute)) {
-        if (rule.checkHintApplicability) {
-          attribute.layouthint.forEach((hint) => {
-            if (rule.isApplicableForHint(hint)) {
-              rules.add(rule.initHint(hint));
-            }
-          });
-        } else {
-          rules.add(rule.initAttribute(attribute));
-        }
-      }
-    });
-
-    attribute.layoutHintRules = rules;
-
-    return attribute;
-  }
-
-  /**
-   * Process layout hint rules in the collection
-   */
-  process(attribute: AttributeModel, attributes: AttributeCollection) {
-    this.all.forEach((rule) => {
-      rule.process(attribute, attributes);
-    });
-  }
-}
-
-export default LayoutHintRuleCollection;

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

@@ -1,67 +0,0 @@
-// @flow
-import BaseLayoutHintRule from "./BaseLayoutHintRule";
-
-import UploadAttributeModel from "../UploadAttributeModel";
-
-import { INITIAL_TOTAL_FILESIZE, MAX_TOTAL_FILESIZE } from "../../../constants";
-
-import type { AttributeType, ILayoutHintRule } from "../../types";
-import type AttributeCollection from "../AttributeCollection";
-import type AttributeModel from "../AttributeModel";
-
-/**
- * This pattern enables showing the upload file size remaining when uploading resources<br>
- * The rule depends on other attributes with the INITIAL_TOTAL_FILESIZE and MAX_TOTAL_FILESIZE layout hints
- */
-class RemainingTotalUploadSize extends BaseLayoutHintRule {
-  /**
-   */
-  static isApplicableForAttribute(attribute: AttributeType): boolean {
-    return attribute instanceof UploadAttributeModel;
-  }
-
-  /**
-   */
-  static initAttribute(): ILayoutHintRule {
-    return new RemainingTotalUploadSize();
-  }
-
-  /**
-   */
-  processUploadInformation(
-    attribute: UploadAttributeModel,
-    attributes: AttributeCollection,
-  ) {
-    const uploadInformationAttributes = attributes.getAttributesByLayoutHint(
-      INITIAL_TOTAL_FILESIZE,
-      MAX_TOTAL_FILESIZE,
-    );
-
-    if (uploadInformationAttributes.length === 2) {
-      const firstHasInitialTotalFileSize =
-        uploadInformationAttributes[0].layouthint.has(INITIAL_TOTAL_FILESIZE);
-
-      const initialTotalFileSize = firstHasInitialTotalFileSize
-        ? uploadInformationAttributes[0].value
-        : uploadInformationAttributes[1].value;
-
-      const maxTotalFileSize = firstHasInitialTotalFileSize
-        ? uploadInformationAttributes[1].value
-        : uploadInformationAttributes[0].value;
-
-      attribute.initialTotalFileSize = initialTotalFileSize;
-      attribute.maxTotalFileSize = maxTotalFileSize;
-    }
-  }
-
-  /**
-   * Sets tresholds for initial and maximum upload file size
-   */
-  process(attribute: AttributeModel, attributes: AttributeCollection): void {
-    if (attribute instanceof UploadAttributeModel) {
-      this.processUploadInformation(attribute, attributes);
-    }
-  }
-}
-
-export default RemainingTotalUploadSize;

package/src/models/attributes/layouthint-rules/__mock__/MockedCollectionFactory.js

@@ -1,54 +0,0 @@
-import AttributeCollection from "../../AttributeCollection";
-
-/**
- */
-export default class MockedCollectionFactory {
-  /**
-   */
-  constructor() {
-    this._data = [];
-    this._contributions = [];
-  }
-
-  /**
-   */
-  addControlAttribute(elementid, options = [], suggestion = [], hint = []) {
-    this._data.push({
-      elementid,
-      dynamicschema: options.map((option) => ({
-        code: option,
-        label: option,
-      })),
-      suggestion,
-    });
-
-    this._contributions.push({
-      [elementid]: {
-        type: "string",
-        enumerated: true,
-        multiplechoice: true,
-        layouthint: [...hint, "combobox"],
-      },
-    });
-  }
-
-  /**
-   */
-  addDependentAttribute(elementid, hint = []) {
-    this._data.push({
-      elementid,
-    });
-    this._contributions.push({
-      [elementid]: {
-        type: "string",
-        layouthint: hint,
-      },
-    });
-  }
-
-  /**
-   */
-  createCollection() {
-    return new AttributeCollection(this._data, this._contributions);
-  }
-}

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

@@ -1,29 +0,0 @@
-import BaseLayoutHintRule from "../BaseLayoutHintRule";
-import { IllegalStateException } from "../../../../exceptions";
-
-describe("base layouthint rule", () => {
-  it("throws when isApplicableForHint is not implemented", () => {
-    expect(() => {
-      BaseLayoutHintRule.isApplicableForHint("hint");
-    }).toThrow(IllegalStateException);
-  });
-
-  it("throws when initAttribute is not implemented", () => {
-    expect(() => {
-      BaseLayoutHintRule.initAttribute();
-    }).toThrow(IllegalStateException);
-  });
-
-  it("throws when initHint is not implemented", () => {
-    expect(() => {
-      BaseLayoutHintRule.initHint();
-    }).toThrow(IllegalStateException);
-  });
-
-  it("throws when process is not implemented", () => {
-    const rule = new BaseLayoutHintRule();
-    expect(() => {
-      rule.process();
-    }).toThrow(IllegalStateException);
-  });
-});

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

@@ -1,310 +0,0 @@
-import MockedCollectionFactory from "../__mock__/MockedCollectionFactory";
-import DependentAttribute from "../DependentAttribute";
-
-import StringAttributeModel from "../../StringAttributeModel";
-import { ConfigurationException } from "../../../../exceptions";
-
-describe("depending attribute - visibility", () => {
-  it("needs to check hint applicability", () => {
-    expect(DependentAttribute.checkHintApplicability).toBe(true);
-  });
-
-  it("is applicable for every attribute", () => {
-    expect(
-      DependentAttribute.isApplicableForAttribute(new StringAttributeModel()),
-    ).toBe(true);
-  });
-
-  it("checks applicability for hint", () => {
-    expect(DependentAttribute.isApplicableForHint("bla")).toBe(false);
-    expect(DependentAttribute.isApplicableForHint("dependent-attribute")).toBe(
-      false,
-    );
-    expect(
-      DependentAttribute.isApplicableForHint("dependent-attribute:show sss"),
-    ).toBe(true);
-    expect(
-      DependentAttribute.isApplicableForHint("dependent-attribute: show sss"),
-    ).toBe(true);
-    expect(
-      DependentAttribute.isApplicableForHint("dependent-attribute:hide sss"),
-    ).toBe(true);
-    expect(
-      DependentAttribute.isApplicableForHint("dependent-attribute:enable sss"),
-    ).toBe(false);
-  });
-
-  it("throws on invalid hint", () => {
-    expect(() => {
-      DependentAttribute.initHint("dependent-attribute:bla");
-    }).toThrow(ConfigurationException);
-  });
-
-  it("parse layout hint on init", () => {
-    const showEquals = DependentAttribute.initHint(
-      "dependent-attribute:show when dependent-control:controlA equals code1",
-    );
-
-    expect(showEquals).toBeInstanceOf(DependentAttribute);
-    expect(showEquals.action).toBe("show");
-    expect(showEquals.control).toBe("controlA");
-    expect(showEquals.operator).toBe("equals");
-    expect(showEquals.options).toStrictEqual(["code1"]);
-
-    const showEqualsExtraSpaces = DependentAttribute.initHint(
-      "dependent-attribute: show when dependent-control: controlA equals code1",
-    );
-
-    expect(showEqualsExtraSpaces).toBeInstanceOf(DependentAttribute);
-    expect(showEqualsExtraSpaces.action).toBe("show");
-    expect(showEqualsExtraSpaces.control).toBe("controlA");
-    expect(showEqualsExtraSpaces.operator).toBe("equals");
-    expect(showEqualsExtraSpaces.options).toStrictEqual(["code1"]);
-
-    const hideTwoOptions = DependentAttribute.initHint(
-      "dependent-attribute:hide when dependent-control:controlA includes code1|code2",
-    );
-
-    expect(hideTwoOptions).toBeInstanceOf(DependentAttribute);
-    expect(hideTwoOptions.action).toBe("hide");
-    expect(hideTwoOptions.control).toBe("controlA");
-    expect(hideTwoOptions.operator).toBe("includes");
-    expect(hideTwoOptions.options).toStrictEqual(["code1", "code2"]);
-
-    const hideTwoOptionsSpaces = DependentAttribute.initHint(
-      "dependent-attribute:hide when dependent-control:controlA includes code1 | code2",
-    );
-
-    expect(hideTwoOptionsSpaces).toBeInstanceOf(DependentAttribute);
-    expect(hideTwoOptionsSpaces.action).toBe("hide");
-    expect(hideTwoOptionsSpaces.control).toBe("controlA");
-    expect(hideTwoOptionsSpaces.operator).toBe("includes");
-    expect(hideTwoOptionsSpaces.options).toStrictEqual(["code1", "code2"]);
-  });
-
-  const expectVisible = (mockedCollection, key) => {
-    expect(mockedCollection.getAttributeByKey(key).isVisible).toBe(true);
-    expect(mockedCollection.getAttributeByKey(key).isHidden).toBe(false);
-  };
-
-  const expectHidden = (mockedCollection, key) => {
-    expect(mockedCollection.getAttributeByKey(key).isVisible).toBe(false);
-    expect(mockedCollection.getAttributeByKey(key).isHidden).toBe(true);
-  };
-
-  it("returns visible when no visibility specific hint is set", () => {
-    const mockedCollectionFactory = new MockedCollectionFactory();
-
-    mockedCollectionFactory.addControlAttribute(
-      "attributeControl",
-      ["code1", "code2", "code3", "code4", "code5", "code6"],
-      ["code2", "code4", "code6"],
-      ["dependent-control: Control A"],
-    );
-    mockedCollectionFactory.addDependentAttribute("attributeUnknownHint", [
-      "unknown-hint",
-    ]);
-    mockedCollectionFactory.addDependentAttribute(
-      "attributeHasNonExistingControl",
-      [
-        "dependent-attribute: show when dependent-control: Control B equals code2",
-      ],
-    );
-
-    const mockedCollection = mockedCollectionFactory.createCollection();
-
-    expectVisible(mockedCollection, "attributeUnknownHint");
-    expectVisible(mockedCollection, "attributeHasNonExistingControl");
-  });
-
-  it("returns visible", () => {
-    const mockedCollectionFactory = new MockedCollectionFactory();
-
-    mockedCollectionFactory.addControlAttribute(
-      "attributeControl",
-      ["code1", "code2"],
-      ["code2"],
-      ["dependent-control: Control A"],
-    );
-    mockedCollectionFactory.addDependentAttribute("showEqualsSelected", [
-      "dependent-attribute:show when dependent-control: Control A equals code2",
-    ]);
-    mockedCollectionFactory.addDependentAttribute("hideEqualsNotSelected", [
-      "dependent-attribute:hide when dependent-control:Control A equals code1",
-    ]);
-    mockedCollectionFactory.addDependentAttribute("showIncludesSelected", [
-      "dependent-attribute:show when dependent-control: Control A includes code2",
-    ]);
-    mockedCollectionFactory.addDependentAttribute("hideIncludesNotSelected", [
-      "dependent-attribute:hide when dependent-control: Control A includes code1",
-    ]);
-
-    mockedCollectionFactory.addDependentAttribute("showNotEqualsSelected", [
-      "dependent-attribute:show when dependent-control: Control A notEquals code1",
-    ]);
-    mockedCollectionFactory.addDependentAttribute("hideNotEqualsNotSelected", [
-      "dependent-attribute:hide when dependent-control: Control A notEquals code2",
-    ]);
-    mockedCollectionFactory.addDependentAttribute("showNotIncludesSelected", [
-      "dependent-attribute:show when dependent-control: Control A notIncludes code1",
-    ]);
-    mockedCollectionFactory.addDependentAttribute(
-      "hideNotIncludesNotSelected",
-      [
-        "dependent-attribute: hide when dependent-control: Control A notIncludes code2",
-      ],
-    );
-
-    const mockedCollection = mockedCollectionFactory.createCollection();
-
-    expectVisible(mockedCollection, "showEqualsSelected");
-    expectVisible(mockedCollection, "hideEqualsNotSelected");
-    expectVisible(mockedCollection, "showIncludesSelected");
-    expectVisible(mockedCollection, "hideIncludesNotSelected");
-    expectVisible(mockedCollection, "showNotEqualsSelected");
-    expectVisible(mockedCollection, "hideNotEqualsNotSelected");
-    expectVisible(mockedCollection, "showNotIncludesSelected");
-    expectVisible(mockedCollection, "hideNotIncludesNotSelected");
-  });
-
-  it("returns hidden", () => {
-    const mockedCollectionFactory = new MockedCollectionFactory();
-
-    mockedCollectionFactory.addControlAttribute(
-      "attributeControl",
-      ["code1", "code2"],
-      ["code2"],
-      ["dependent-control: Control A"],
-    );
-    mockedCollectionFactory.addDependentAttribute("showEqualsNotSelected", [
-      "dependent-attribute:show when dependent-control: Control A equals code1",
-    ]);
-    mockedCollectionFactory.addDependentAttribute("hideEqualsSelected", [
-      "dependent-attribute:hide when dependent-control: Control A equals code2",
-    ]);
-    mockedCollectionFactory.addDependentAttribute("showIncludesNotSelected", [
-      "dependent-attribute:show when dependent-control: Control A includes code1",
-    ]);
-    mockedCollectionFactory.addDependentAttribute("hideIncludesSelected", [
-      "dependent-attribute:hide when dependent-control: Control A includes code2",
-    ]);
-
-    const mockedCollection = mockedCollectionFactory.createCollection();
-
-    expectHidden(mockedCollection, "showEqualsNotSelected");
-    expectHidden(mockedCollection, "hideEqualsSelected");
-    expectHidden(mockedCollection, "showIncludesNotSelected");
-    expectHidden(mockedCollection, "hideIncludesSelected");
-  });
-
-  it("can handle an attribute that is dependend on an other dependent attribute", () => {
-    const mockedCollectionFactory = new MockedCollectionFactory();
-
-    mockedCollectionFactory.addControlAttribute(
-      "attributeControlA",
-      ["code1", "code2"],
-      ["code2"],
-      ["dependent-control: Control A"],
-    );
-    mockedCollectionFactory.addControlAttribute(
-      "attributeControlB",
-      ["code1", "code2"],
-      ["code2"],
-      [
-        "dependent-control: Control B",
-        "dependent-attribute:show when dependent-control: Control A equals code2",
-      ],
-    );
-    mockedCollectionFactory.addControlAttribute(
-      "attributeControlC",
-      ["code1", "code2"],
-      ["code2"],
-      [
-        "dependent-control: Control C",
-        "dependent-attribute:show when dependent-control: Control B equals code2",
-      ],
-    );
-    mockedCollectionFactory.addControlAttribute(
-      "attributeControlD",
-      ["code1", "code2"],
-      ["code2"],
-      [
-        "dependent-control: Control D",
-        "dependent-attribute:show when dependent-control: Control C equals code1",
-      ],
-    );
-    mockedCollectionFactory.addControlAttribute(
-      "attributeControlE",
-      ["code1", "code2"],
-      ["code2"],
-      [
-        "dependent-control: Control E",
-        "dependent-attribute:show when dependent-control: Control D equals code2",
-      ],
-    );
-
-    mockedCollectionFactory.addDependentAttribute("show1", [
-      "dependent-attribute:show when dependent-control: Control A equals code2",
-    ]);
-    mockedCollectionFactory.addDependentAttribute("show2", [
-      "dependent-attribute:show when dependent-control: Control B equals code2",
-    ]);
-    mockedCollectionFactory.addDependentAttribute("show3", [
-      "dependent-attribute:show when dependent-control: Control C equals code2",
-    ]);
-    mockedCollectionFactory.addDependentAttribute("show4", [
-      "dependent-attribute:show when dependent-control: Control D equals code2",
-    ]);
-    mockedCollectionFactory.addDependentAttribute("show5", [
-      "dependent-attribute:show when dependent-control: Control E equals code2",
-    ]);
-
-    const mockedCollection = mockedCollectionFactory.createCollection();
-
-    expectVisible(mockedCollection, "show1");
-    expectVisible(mockedCollection, "show2");
-    expectVisible(mockedCollection, "show3");
-    expectVisible(mockedCollection, "attributeControlB");
-    expectVisible(mockedCollection, "attributeControlC");
-
-    expectHidden(mockedCollection, "show4");
-    expectHidden(mockedCollection, "show5");
-  });
-
-  it("can handle an attribute with multiple dependent attributes", () => {
-    const mockedCollectionFactory = new MockedCollectionFactory();
-
-    mockedCollectionFactory.addControlAttribute(
-      "attributeControlA",
-      ["code1", "code2"],
-      [],
-      ["dependent-control: Control A"],
-    );
-
-    mockedCollectionFactory.addControlAttribute(
-      "attributeControlB",
-      ["code1", "code2"],
-      [],
-      ["dependent-control: Control B"],
-    );
-
-    mockedCollectionFactory.addDependentAttribute("depending", [
-      "dependent-attribute:show when dependent-control: Control A equals code1",
-      "dependent-attribute:show when dependent-control: Control B equals code1",
-    ]);
-
-    const mockedCollection = mockedCollectionFactory.createCollection();
-
-    expectHidden(mockedCollection, "depending");
-
-    mockedCollection.getAttributeByKey("attributeControlA").update("code1");
-    mockedCollection.processLayoutHintRules();
-
-    expectHidden(mockedCollection, "depending");
-
-    mockedCollection.getAttributeByKey("attributeControlB").update("code1");
-    mockedCollection.processLayoutHintRules();
-
-    expectVisible(mockedCollection, "depending");
-  });
-});

package/src/models/attributes/layouthint-rules/__tests__/LayoutHintRuleCollection.spec.js

@@ -1,58 +0,0 @@
-import LayoutHintRuleCollection, {
-  addLayoutHintRule,
-  updateLayoutHintRules,
-} from "../LayoutHintRuleCollection";
-import StringAttributeModel from "../../StringAttributeModel";
-import BaseLayoutHintRule from "../BaseLayoutHintRule";
-import { IllegalReturnException } from "../../../../exceptions";
-
-describe("layout hint rule collection", () => {
-  it("can set rules on an attribute", () => {
-    const attribute = new StringAttributeModel();
-
-    const attrWithoutRules =
-      LayoutHintRuleCollection.setLayoutHintRules(attribute);
-
-    expect(attrWithoutRules.layoutHintRules.size).toBe(0);
-
-    attribute.layouthint.add(
-      "dependent-attribute:show when dependent-control:bla equals one",
-    );
-    const attrWithRules =
-      LayoutHintRuleCollection.setLayoutHintRules(attribute);
-    expect(attrWithRules.layoutHintRules.size).toBe(1);
-  });
-
-  it("can add a custom rule", () => {
-    const ruleCollection = new LayoutHintRuleCollection();
-    expect(ruleCollection.allRules).toHaveLength(2);
-
-    class TestRule extends BaseLayoutHintRule {
-      initAttribute() {
-        return new TestRule();
-      }
-
-      process() {
-        return jest.fn();
-      }
-    }
-
-    addLayoutHintRule(TestRule);
-
-    expect(ruleCollection.allRules).toHaveLength(3);
-
-    updateLayoutHintRules((rules) => {
-      return rules.filter((rule) => rule !== TestRule);
-    });
-
-    expect(ruleCollection.allRules).toHaveLength(2);
-  });
-
-  it("throws when updater is not returning an array", () => {
-    expect(() => {
-      updateLayoutHintRules(() => {
-        return false;
-      });
-    }).toThrow(IllegalReturnException);
-  });
-});

package/src/models/attributes/layouthint-rules/__tests__/RemainingTotalUploadSize.spec.js

@@ -1,24 +0,0 @@
-import RemainingTotalUploadSize from "../RemainingTotalUploadSize";
-
-import StringAttributeModel from "../../StringAttributeModel";
-import UploadAttributeModel from "../../UploadAttributeModel";
-
-describe("remaining total upload size", () => {
-  it("does not needs to check hint applicability", () => {
-    expect(RemainingTotalUploadSize.checkHintApplicability).toBe(false);
-  });
-
-  it("needs to check hint applicability", () => {
-    expect(
-      RemainingTotalUploadSize.isApplicableForAttribute(
-        new StringAttributeModel(),
-      ),
-    ).toBe(false);
-
-    expect(
-      RemainingTotalUploadSize.isApplicableForAttribute(
-        new UploadAttributeModel(),
-      ),
-    ).toBe(true);
-  });
-});