@aehrc/smart-forms-renderer 0.36.0 → 0.37.2

package/src/utils/initialise.ts

@@ -17,6 +17,7 @@
 
 import { evaluateInitialEnableWhenExpressions } from './enableWhenExpression';
 import { getFirstVisibleTab } from './tabs';
+import { getFirstVisiblePage } from './page';
 import type {
   Expression,
   Questionnaire,
@@ -28,6 +29,7 @@ import type {
 } from 'fhir/r4';
 import type { EnableWhenExpressions, EnableWhenItems } from '../interfaces/enableWhen.interface';
 import type { Tabs } from '../interfaces/tab.interface';
+import type { Pages } from '../interfaces/page.interface';
 import { assignPopulatedAnswersToEnableWhen } from './enableWhen';
 import type { CalculatedExpression } from '../interfaces/calculatedExpression.interface';
 import { evaluateInitialCalculatedExpressions } from './calculatedExpression';
@@ -320,6 +322,7 @@ export interface initialFormFromResponseParams {
   calculatedExpressions: Record<string, CalculatedExpression[]>;
   variablesFhirPath: Record<string, Expression[]>;
   tabs: Tabs;
+  pages: Pages;
   fhirPathContext: Record<string, any>;
 }
 
@@ -329,6 +332,7 @@ export function initialiseFormFromResponse(params: initialFormFromResponseParams
   initialEnableWhenExpressions: EnableWhenExpressions;
   initialCalculatedExpressions: Record<string, CalculatedExpression[]>;
   firstVisibleTab: number;
+  firstVisiblePage: number;
   updatedFhirPathContext: Record<string, any>;
 } {
   const {
@@ -338,6 +342,7 @@ export function initialiseFormFromResponse(params: initialFormFromResponseParams
     calculatedExpressions,
     variablesFhirPath,
     tabs,
+    pages,
     fhirPathContext
   } = params;
   const initialResponseItemMap = createQuestionnaireResponseItemMap(questionnaireResponse);
@@ -373,12 +378,18 @@ export function initialiseFormFromResponse(params: initialFormFromResponseParams
       ? getFirstVisibleTab(tabs, initialisedItems, initialEnableWhenExpressions)
       : 0;
 
+  const firstVisiblePage =
+    Object.keys(pages).length > 0
+      ? getFirstVisiblePage(pages, initialisedItems, initialEnableWhenExpressions)
+      : 0;
+
   return {
     initialEnableWhenItems: initialisedItems,
     initialEnableWhenLinkedQuestions: linkedQuestions,
     initialEnableWhenExpressions,
     initialCalculatedExpressions,
     firstVisibleTab,
+    firstVisiblePage,
     updatedFhirPathContext
   };
 }

package/src/utils/page.ts

@@ -0,0 +1,134 @@
+import type { Pages } from '../interfaces/page.interface';
+import type { EnableWhenExpressions, EnableWhenItems } from '../interfaces/enableWhen.interface';
+import type { QuestionnaireItem } from 'fhir/r4';
+import { isSpecificItemControl } from './itemControl';
+import { isHiddenByEnableWhen } from './qItem';
+import { structuredDataCapture } from 'fhir-sdc-helpers';
+
+export function getFirstVisiblePage(
+  pages: Pages,
+  enableWhenItems: EnableWhenItems,
+  enableWhenExpressions: EnableWhenExpressions
+) {
+  // Only singleEnableWhenItems are relevant for page operations
+  const { singleItems } = enableWhenItems;
+  const { singleExpressions } = enableWhenExpressions;
+
+  return Object.entries(pages)
+    .sort(([, pageA], [, pageB]) => pageA.pageIndex - pageB.pageIndex)
+    .findIndex(([pageLinkId, page]) => {
+      if (page.isHidden) {
+        return false;
+      }
+
+      const singleItem = singleItems[pageLinkId];
+      if (singleItem) {
+        return singleItem.isEnabled;
+      }
+
+      const singleExpression = singleExpressions[pageLinkId];
+      if (singleExpression) {
+        return singleExpression.isEnabled;
+      }
+
+      return true;
+    });
+}
+
+/**
+ * Checks if all of the items in a qItem array is a page item
+ * Returns true if all items is page item
+ * Returns false if only have one item
+ *
+ * @author Riza Nafis
+ */
+export function everyIsPages(topLevelQItem: QuestionnaireItem[] | undefined): boolean {
+  if (!topLevelQItem) return false;
+
+  if (isPageContainer(topLevelQItem)) return false;
+
+  return topLevelQItem.every((i: QuestionnaireItem) => isPage(i));
+}
+
+export function isPageContainer(topLevelQItem: QuestionnaireItem[] | undefined): boolean {
+  const anyPage = topLevelQItem?.filter(isPage);
+
+  if (!anyPage) return false;
+
+  return anyPage.some((page) => page.item?.every((i) => i.type === 'group') || false);
+}
+
+/**
+ * Checks if any of the items in a qItem array is a page item
+ * Returns true if there is at least one page item
+ *
+ * @author Riza Nafis
+ */
+export function containsPages(topLevelQItem: QuestionnaireItem): boolean {
+  if (!topLevelQItem.item) {
+    return false;
+  }
+
+  const pages = topLevelQItem.item.filter((i) => isPage(i));
+  return pages.length > 0;
+}
+
+/**
+ * Check if a qItem is a page item
+ *
+ * @author Riza Nafis
+ */
+export function isPage(item: QuestionnaireItem) {
+  return isSpecificItemControl(item, 'page');
+}
+
+/**
+ * Create a `Record<linkId, Pages>` key-value pair for all page items in a qItem array
+ *
+ * @author Riza Nafis
+ */
+export function constructPagesWithProperties(
+  qItems: QuestionnaireItem[] | undefined,
+  hasPageContainer: boolean
+): Pages {
+  if (!qItems) return {};
+
+  const qItemPages = hasPageContainer ? qItems : qItems.filter(isPage);
+
+  const pages: Pages = {};
+  for (const [i, qItem] of qItemPages.entries()) {
+    pages[qItem.linkId] = {
+      pageIndex: i,
+      isComplete: false,
+      isHidden: structuredDataCapture.getHidden(qItem) ?? false
+    };
+  }
+  return pages;
+}
+
+interface contructPagesWithVisibilityParams {
+  pages: Pages;
+  enableWhenIsActivated: boolean;
+  enableWhenItems: EnableWhenItems;
+  enableWhenExpressions: EnableWhenExpressions;
+}
+
+export function constructPagesWithVisibility(
+  params: contructPagesWithVisibilityParams
+): { linkId: string; isVisible: boolean }[] {
+  const { pages, enableWhenIsActivated, enableWhenItems, enableWhenExpressions } = params;
+
+  return Object.entries(pages).map(([linkId]) => {
+    const isVisible = !isHiddenByEnableWhen({
+      linkId,
+      enableWhenIsActivated,
+      enableWhenItems,
+      enableWhenExpressions
+    });
+
+    return {
+      linkId,
+      isVisible
+    };
+  });
+}

package/src/utils/questionnaireStoreUtils/createQuestionaireModel.ts

@@ -17,11 +17,13 @@
 
 import type { Questionnaire } from 'fhir/r4';
 import type { Tabs } from '../../interfaces/tab.interface';
+import type { Pages } from '../../interfaces/page.interface';
 import type { LaunchContext } from '../../interfaces/populate.interface';
 import type { QuestionnaireModel } from '../../interfaces/questionnaireStore.interface';
 import { extractLaunchContexts } from './extractLaunchContext';
 import { extractQuestionnaireLevelVariables } from './extractVariables';
 import { extractTabs } from './extractTabs';
+import { extractPages } from './extractPages';
 import { extractContainedValueSets } from './extractContainedValueSets';
 import { extractOtherExtensions } from './extractOtherExtensions';
 import type { Variables } from '../../interfaces/variables.interface';
@@ -41,6 +43,7 @@ export async function createQuestionnaireModel(
 
   const itemTypes: Record<string, string> = Object.fromEntries(getLinkIdTypeTuples(questionnaire));
   const tabs: Tabs = extractTabs(questionnaire);
+  const pages: Pages = extractPages(questionnaire);
 
   const launchContexts: Record<string, LaunchContext> = extractLaunchContexts(questionnaire);
 
@@ -98,6 +101,7 @@ export async function createQuestionnaireModel(
   return {
     itemTypes,
     tabs,
+    pages,
     variables,
     launchContexts,
     enableWhenItems,
@@ -116,6 +120,7 @@ function createEmptyModel(): QuestionnaireModel {
   return {
     itemTypes: {},
     tabs: {},
+    pages: {},
     variables: { fhirPathVariables: {}, xFhirQueryVariables: {} },
     launchContexts: {},
     calculatedExpressions: {},

package/src/utils/questionnaireStoreUtils/extractPages.ts

@@ -0,0 +1,24 @@
+import type { Questionnaire } from 'fhir/r4';
+import type { Pages } from '../../interfaces/page.interface';
+import { constructPagesWithProperties, isPage, isPageContainer } from '../page';
+
+export function extractPages(questionnaire: Questionnaire): Pages {
+  if (!questionnaire.item || questionnaire.item.length === 0) {
+    return {};
+  }
+
+  if (!isPageContainer(questionnaire.item)) {
+    return constructPagesWithProperties(questionnaire.item, false);
+  }
+
+  let totalPages = {};
+  for (const topLevelItem of questionnaire.item) {
+    const items = topLevelItem.item;
+    const topLevelItemIsPageContainer = isPage(topLevelItem);
+
+    const pages = constructPagesWithProperties(items, topLevelItemIsPageContainer);
+    totalPages = { ...totalPages, ...pages };
+  }
+
+  return totalPages;
+}