@beinformed/ui 1.61.0 → 1.62.0

package/src/models/concepts/__tests__/RelatedConcepts.spec.js

@@ -0,0 +1,60 @@
+import { relatedConcepts } from "../__mock__/related_concepts";
+import ConceptIndexModel from "../ConceptIndexModel";
+
+describe("Related concepts", () => {
+  it("Should be able to create a relatedConceptsModel from RelatedConcepts json", () => {
+    expect(relatedConcepts).toBeInstanceOf(ConceptIndexModel);
+
+    expect(relatedConcepts.label).toBe("Related concepts of content");
+
+    expect(relatedConcepts.label).toBe("Related concepts of content");
+    expect(relatedConcepts.selfhref.toString()).toBe(
+      "/content/bundle-com.beinformed.source.Highlevelrequirements/ResearchGrant/High%20level%20requirements.formalsource/relatedConcepts?entryDate=2025-06-03",
+    );
+
+    expect(relatedConcepts.entryDate).toBe("2025-06-03");
+    expect(relatedConcepts.modelCategoryFilter.label).toBe("Model category");
+
+    expect(relatedConcepts.items.size).toBe(116);
+
+    const firstItem = relatedConcepts.items.first;
+    expect(firstItem.key).toBe(
+      "SystemMustSendAutomatedNotificationsForStatusChanges",
+    );
+    expect(firstItem.label).toBe(
+      "System must send automated notifications for status changes.",
+    );
+    expect(firstItem.modelCategory).toBe("Requirements");
+    expect(firstItem.selfhref.toString()).toBe(
+      "/concepts/bundle-com.beinformed.frames.ResearchGrantRequirements/frames.beimodel.json/SystemMustSendAutomatedNotificationsForStatusChanges?entryDate=2025-06-03",
+    );
+    expect(firstItem.conceptTypeLink.href.toString()).toBe(
+      "/concepttypes/bundle-com.beinformed.research.grant.metamodels/High%20level%20requirements.bixml/ArchitecturalSignificantRequirement",
+    );
+
+    expect(firstItem.fragment.sectionId).toBe(
+      "AutomatedNotifications_Requirement",
+    );
+    expect(firstItem.fragment.text).toBeUndefined();
+
+    const secondItem = relatedConcepts.items.get(1);
+
+    expect(secondItem.key).toBe(
+      "n74UsersHaveMaximumFlexibilityWithinPolicyConstraints",
+    );
+    expect(secondItem.label).toBe(
+      "Users have maximum flexibility within policy constraints",
+    );
+
+    expect(secondItem.modelCategory).toBe("Requirements");
+
+    expect(secondItem.fragment.sectionId).toBe(
+      "MaximumFlexibilityWithinPolicyConstraints",
+    );
+    expect(secondItem.fragment.text).toBe(
+      "<p>Users have maximum flexibility within policy constraints</p>",
+    );
+    expect(secondItem.fragment.startOffset).toBe(0);
+    expect(secondItem.fragment.endOffset).toBe(56);
+  });
+});

package/src/models/concepts/__tests__/SourceReferenceModel.spec.js

@@ -1,9 +1,67 @@
 import SourceReferenceModel from "../SourceReferenceModel";
 
+const data = {
+  label: "Requirement: Implement scoring systems based on predefined cr...",
+  type: "Reference",
+  sourceLabel: "High level requirements",
+  sourceAbbreviation: "HLR-01",
+  _links: {
+    self: {
+      href: "/content/bundle-com.beinformed.source.Highlevelrequirements/ResearchGrant/High%20level%20requirements.formalsource/ScoringAndEvaluationCriteria#ScoringAndEvaluationCriteria_Requirement",
+    },
+    content: {
+      href: "/content/bundle-com.beinformed.source.Highlevelrequirements/ResearchGrant/High%20level%20requirements.formalsource",
+    },
+  },
+  sectionFragment: {
+    text: "Implement scoring systems based on predefined criteria.",
+    startOffset: 12,
+    endOffset: 68,
+  },
+};
+
 describe("sourceReferenceModel", () => {
   it("should be able to create an empty SourceReferenceModel object", () => {
     const sourceReference = new SourceReferenceModel();
 
     expect(sourceReference).toBeInstanceOf(SourceReferenceModel);
   });
+
+  it("can handle source reference data", () => {
+    const sourceReference = new SourceReferenceModel(data);
+
+    expect(sourceReference.label).toBe(
+      "Requirement: Implement scoring systems based on predefined cr...",
+    );
+    expect(sourceReference.sourceLabel).toBe("High level requirements");
+    expect(sourceReference.type).toBe("Reference");
+    expect(sourceReference.sourceAbbreviation).toBe("HLR-01");
+    expect(sourceReference.referenceHash).toBe(6767520005362);
+    expect(sourceReference.fragment.text).toBe(
+      "Implement scoring systems based on predefined criteria.",
+    );
+    expect(sourceReference.fragment.startOffset).toBe(12);
+    expect(sourceReference.fragment.endOffset).toBe(68);
+
+    expect(sourceReference.link.label).toBe(
+      "Requirement: Implement scoring systems based on predefined cr...",
+    );
+    expect(sourceReference.link.sourceLabel).toBe("High level requirements");
+    expect(sourceReference.link.abbreviation).toBe("HLR-01");
+    expect(sourceReference.link.selfhref.path).toBe(
+      "/content/bundle-com.beinformed.source.Highlevelrequirements/ResearchGrant/High%20level%20requirements.formalsource/ScoringAndEvaluationCriteria",
+    );
+
+    expect(sourceReference.link.fragment.text).toBe(
+      "Implement scoring systems based on predefined criteria.",
+    );
+    expect(sourceReference.link.fragment.startOffset).toBe(12);
+    expect(sourceReference.link.fragment.endOffset).toBe(68);
+
+    expect(sourceReference.link.selfhref.state.fragment.text).toBe(
+      "Implement scoring systems based on predefined criteria.",
+    );
+    expect(sourceReference.link.selfhref.state.fragment.startOffset).toBe(12);
+    expect(sourceReference.link.selfhref.state.fragment.endOffset).toBe(68);
+  });
 });

package/src/models/content/ContentLinkModel.js

@@ -11,6 +11,7 @@ import type {
   ModularUIModel,
   IModelWithChildModels,
   ModelOptions,
+  SectionFragment,
 } from "../types";
 
 /**
@@ -107,6 +108,13 @@ export default class ContentLinkModel
     return this.getData("sourceLabel");
   }
 
+  /**
+   *
+   */
+  get abbreviation(): string | null {
+    return this.getData("abbreviation") || this.getData("sourceAbbreviation");
+  }
+
   /**
    */
   createEncodedHref(): Href {
@@ -177,6 +185,14 @@ export default class ContentLinkModel
       );
     }
 
+    if (!selflink.href.state) {
+      selflink.href.state = {
+        fragment: this.fragment,
+      };
+    } else {
+      selflink.href.state.fragment = this.fragment;
+    }
+
     return selflink;
   }
 
@@ -217,6 +233,12 @@ export default class ContentLinkModel
     return null;
   }
 
+  /**
+   */
+  get fragment(): SectionFragment | void {
+    return this.data.sectionFragment;
+  }
+
   /**
    * Children of link model in TOC
    */

package/src/models/content/ContentTOCModel.js

@@ -92,6 +92,12 @@ export default class ContentTOCModel extends ResourceModel {
     return this.getData("label", "");
   }
 
+  /**
+   */
+  get abbreviation(): string | null {
+    return this.getData("abbreviation");
+  }
+
   /**
    * Getting the self link of this list
    */

package/src/models/content/__tests__/ContentIndexModel.spec.js

@@ -30,6 +30,9 @@ describe("content index model", () => {
     const firstLink = contentIndexModel.items.first;
     expect(firstLink).toBeInstanceOf(ContentLinkModel);
 
+    expect(firstLink.label).toBe("Another formal content");
+    expect(firstLink.abbreviation).toBe("AFC-01");
+
     expect(firstLink.encodedHref.toString()).toBe(
       "/content/Content%2FSources%2FFormal%2FAnother%2520formal%2520content.formalsource",
     );

package/src/models/content/__tests__/ContentModel.spec.js

@@ -67,7 +67,7 @@ describe("contentmodel", () => {
     expect(contentModel.relatedConceptsHref.href.toString()).toBe(
       "/content/Incident/Business design/Content/Blaastest.bixml/67beed02/relatedConcepts?entryDate=2021-08-31",
     );
-    expect(contentModel.referenceHash).toBe(-484527882);
+    expect(contentModel.referenceHash).toBe(9969574676612);
   });
 
   it("can handle content service with childsections", () => {
@@ -106,7 +106,7 @@ describe("contentmodel", () => {
     expect(contentModel.relatedConceptsHref.href.toString()).toBe(
       "/content/Incident/Business design/Content/Blaastest.textilesource/uitslag/relatedConcepts?entryDate=2021-08-31",
     );
-    expect(contentModel.referenceHash).toBe(372690030);
+    expect(contentModel.referenceHash).toBe(8236987459042);
 
     const firstChildSectionLink = contentModel.childSectionLinks[0];
     expect(firstChildSectionLink instanceof ContentLinkModel).toBe(true);
@@ -174,7 +174,7 @@ describe("contentmodel", () => {
     expect(contentModel.subSections).toHaveLength(4);
     expect(contentModel.relatedConceptsHrefs).toHaveLength(4);
     expect(contentModel.relatedConceptsHref).toBeNull();
-    expect(contentModel.referenceHash).toBe(-1980124898);
+    expect(contentModel.referenceHash).toBe(3949483866644);
 
     const firstSubSection = contentModel.subSections[0];
     expect(firstSubSection instanceof SubSectionModel).toBe(true);
@@ -199,8 +199,8 @@ describe("contentmodel", () => {
       "/content/Incident/Business design/Content/Blaastest subsections.formalsource/Pass/relatedConcepts?entryDate=2021-08-31",
     );
     expect(firstSubSection.relatedConceptsHref.getReferenceHash()).toBe(
-      145842294,
+      7092890320518,
     );
-    expect(firstSubSection.referenceHash).toBe(145842294);
+    expect(firstSubSection.referenceHash).toBe(7092890320518);
   });
 });

package/src/models/content/__tests__/Formalsource.spec.js

@@ -55,6 +55,10 @@ describe("formalsource", () => {
     expect(completeModel.sections[0].sections).toHaveLength(0);
     expect(completeModel.sections[1].sections).toHaveLength(2);
 
+    expect(completeModel.label).toBe(
+      "Grant Funding Agreement - Terms and Conditions",
+    );
+    expect(completeModel.abbreviation).toBe("GFA-TC-01");
     expect(completeModel.isCompleteSource).toBe(true);
 
     const firstSection = completeModel.sections[0];

package/src/models/content/__tests__/content-index.json

@@ -147,6 +147,7 @@
           "content": {
             "_id": "/Content/Sources/Formal/Another formal content.formalsource",
             "label": "Another formal content",
+            "abbreviation": "AFC-01",
             "_links": {
               "self": {
                 "href": "/content/Content/Sources/Formal/Another%20formal%20content.formalsource"

package/src/models/content/__tests__/formalsource-complete.json

@@ -31,6 +31,7 @@
       }
     },
     "label": "Grant Funding Agreement - Terms and Conditions",
+    "abbreviation": "GFA-TC-01",
     "sections": [
       {
         "_links": {

package/src/models/form/FormObjectModel.js

@@ -541,17 +541,18 @@ export default class FormObjectModel extends BaseModel {
       }
     }
 
-    errors
-      .filter(
-        (error) =>
-          error.id === "Constraint.Mandatory" &&
-          error.anchor?.objectid === this.key &&
-          has(error.anchor, "elementid"),
-      )
-      .forEach((error) => {
-        attributeErrors.push(error);
-      });
-
+    if (Array.isArray(errors)) {
+      errors
+        .filter(
+          (error) =>
+            error.id === "Constraint.Mandatory" &&
+            error.anchor?.objectid === this.key &&
+            has(error.anchor, "elementid"),
+        )
+        .forEach((error) => {
+          attributeErrors.push(error);
+        });
+    }
     this.attributeCollection.updateValidations(attributeErrors);
   }
 

package/src/models/types.js

@@ -262,6 +262,13 @@ export type ContentData = {
   elements: Array<PropertyElement | TextFragmentElement | ContentElement>,
 };
 
+export type SectionFragment = {
+  sectionId?: string,
+  text: string,
+  startOffset: number,
+  endOffset: number,
+};
+
 export type ModelOptions = {
   origin?: ?string,
   contextPath?: ?string,

package/src/utils/helpers/__tests__/createHash.spec.js

@@ -2,10 +2,10 @@ import { createHash } from "../createHash";
 
 describe("createHash", () => {
   it("creates hash from string", () => {
-    expect(createHash("")).toBe(0);
-    expect(createHash("abcdefgh")).toBe(1259673732);
-    expect(createHash(123455)).toBe(0);
-    expect(createHash(null)).toBe(0);
-    expect(createHash()).toBe(0);
+    expect(createHash("")).toBe(729279156);
+    expect(createHash("abcdefgh")).toBe(17595859189820);
+    expect(createHash(123455)).toBe(15900277965517);
+    expect(createHash(null)).toBe(711079339769);
+    expect(createHash()).toBe(4721361581144);
   });
 });

package/src/utils/helpers/createHash.js

@@ -1,28 +1,28 @@
 // @flow
+import hash from "hash-it";
+
 import type Href from "../../models/href/Href";
+import type { SectionFragment } from "../../models";
 
 /**
  * https://werxltd.com/wp/2010/05/13/javascript-implementation-of-javas-string-hashcode-method/
  */
 const createHash = (str: string): number => {
-  if (!str) return 0;
-
-  let hash = 0;
-  for (let i = 0; i < str.length; i++) {
-    hash = (hash << 5) - hash + str.charCodeAt(i);
-    hash = hash & hash;
-  }
-  return hash;
+  return hash(str);
 };
 
 /**
  */
-const createHashFromHref = (href: Href): number => {
+const createHashFromHref = (href: Href, fragment?: SectionFragment): number => {
   const hrefString = href.hash
     ? [href.toString(), href.hash].join("#")
     : href.toString();
 
-  return createHash(hrefString);
+  if (fragment) {
+    return hash({ hrefString, fragment });
+  }
+
+  return hash(hrefString);
 };
 
 export { createHash, createHashFromHref };