@aehrc/smart-forms-renderer 0.1.0

package/dist/interfaces/answerExpression.interface.d.ts

@@ -0,0 +1,5 @@
+import type { QuestionnaireItemAnswerOption } from 'fhir/r4';
+export interface AnswerExpression {
+    expression: string;
+    value?: QuestionnaireItemAnswerOption;
+}

package/dist/interfaces/calculatedExpression.interface.d.ts

@@ -0,0 +1,4 @@
+export interface CalculatedExpression {
+    expression: string;
+    value?: number | string;
+}

package/dist/interfaces/choice.enum.d.ts

@@ -0,0 +1,20 @@
+export declare enum QItemChoiceControl {
+    Radio = "radio",
+    Select = "select",
+    Autocomplete = "autocomplete",
+    Checkbox = "check-box"
+}
+export declare enum QItemOpenChoiceControl {
+    Select = "select",
+    Autocomplete = "autocomplete",
+    Checkbox = "check-box",
+    Radio = "radio"
+}
+export declare enum QItemChoiceOrientation {
+    Horizontal = "horizontal",
+    Vertical = "vertical"
+}
+export declare enum CheckBoxOptionType {
+    AnswerOption = "answerOption",
+    AnswerValueSet = "answerValueSet"
+}

package/dist/interfaces/enableWhen.interface.d.ts

@@ -0,0 +1,15 @@
+import type { QuestionnaireItem, QuestionnaireItemEnableWhen, QuestionnaireResponseItemAnswer } from 'fhir/r4';
+export interface EnableWhenExpression {
+    expression: string;
+    isEnabled?: boolean;
+}
+export type EnableWhenItems = Record<string, EnableWhenItemProperties>;
+export interface EnableWhenItemProperties {
+    linked: EnableWhenLinkedItem[];
+    isEnabled: boolean;
+    enableBehavior?: QuestionnaireItem['enableBehavior'];
+}
+export interface EnableWhenLinkedItem {
+    enableWhen: QuestionnaireItemEnableWhen;
+    answer?: QuestionnaireResponseItemAnswer[];
+}

package/dist/interfaces/groupTable.interface.d.ts

@@ -0,0 +1,5 @@
+import type { QuestionnaireResponseItem } from 'fhir/r4';
+export interface GroupTableRow {
+    nanoId: string;
+    qrItem: QuestionnaireResponseItem | null;
+}

package/dist/interfaces/populate.interface.d.ts

@@ -0,0 +1,41 @@
+import type { Coding, Expression, Extension, Reference } from 'fhir/r4';
+export interface LaunchContext extends Extension {
+    url: 'http://hl7.org/fhir/uv/sdc/StructureDefinition/sdc-questionnaire-launchContext';
+    extension: LaunchContextExtensions;
+}
+type LaunchContextExtensions = [LaunchContextName, LaunchContextType] | [LaunchContextName, LaunchContextType, LaunchContextDescription];
+type LaunchContextName = LaunchContextNameId | LaunchContextNameCoding;
+interface LaunchContextNameId extends Extension {
+    url: 'name';
+    valueId: string;
+}
+interface LaunchContextNameCoding extends Extension {
+    url: 'name';
+    valueCoding: LaunchContextNameCodingValueCoding;
+}
+interface LaunchContextNameCodingValueCoding extends Coding {
+    code: 'patient' | 'encounter' | 'location' | 'user' | 'study';
+}
+interface LaunchContextType extends Extension {
+    url: 'type';
+    valueCode: FhirResourceString;
+}
+interface LaunchContextDescription extends Extension {
+    url: 'description';
+    valueString: string;
+}
+export type FhirResourceString = 'Account' | 'ActivityDefinition' | 'AdverseEvent' | 'AllergyIntolerance' | 'Appointment' | 'AppointmentResponse' | 'AuditEvent' | 'Basic' | 'Binary' | 'BiologicallyDerivedProduct' | 'BodyStructure' | 'Bundle' | 'CapabilityStatement' | 'CarePlan' | 'CareTeam' | 'CatalogEntry' | 'ChargeItem' | 'ChargeItemDefinition' | 'Claim' | 'ClaimResponse' | 'ClinicalImpression' | 'CodeSystem' | 'Communication' | 'CommunicationRequest' | 'CompartmentDefinition' | 'Composition' | 'ConceptMap' | 'Condition' | 'Consent' | 'Contract' | 'Coverage' | 'CoverageEligibilityRequest' | 'CoverageEligibilityResponse' | 'DetectedIssue' | 'Device' | 'DeviceDefinition' | 'DeviceMetric' | 'DeviceRequest' | 'DeviceUseStatement' | 'DiagnosticReport' | 'DocumentManifest' | 'DocumentReference' | 'EffectEvidenceSynthesis' | 'Encounter' | 'Endpoint' | 'EnrollmentRequest' | 'EnrollmentResponse' | 'EpisodeOfCare' | 'EventDefinition' | 'Evidence' | 'EvidenceVariable' | 'ExampleScenario' | 'ExplanationOfBenefit' | 'FamilyMemberHistory' | 'Flag' | 'Goal' | 'GraphDefinition' | 'Group' | 'GuidanceResponse' | 'HealthcareService' | 'ImagingStudy' | 'Immunization' | 'ImmunizationEvaluation' | 'ImmunizationRecommendation' | 'ImplementationGuide' | 'InsurancePlan' | 'Invoice' | 'Library' | 'Linkage' | 'List' | 'Location' | 'Measure' | 'MeasureReport' | 'Media' | 'Medication' | 'MedicationAdministration' | 'MedicationDispense' | 'MedicationKnowledge' | 'MedicationRequest' | 'MedicationStatement' | 'MedicinalProduct' | 'MedicinalProductAuthorization' | 'MedicinalProductContraindication' | 'MedicinalProductIndication' | 'MedicinalProductIngredient' | 'MedicinalProductInteraction' | 'MedicinalProductManufactured' | 'MedicinalProductPackaged' | 'MedicinalProductPharmaceutical' | 'MedicinalProductUndesirableEffect' | 'MessageDefinition' | 'MessageHeader' | 'MolecularSequence' | 'NamingSystem' | 'NutritionOrder' | 'Observation' | 'ObservationDefinition' | 'OperationDefinition' | 'OperationOutcome' | 'Organization' | 'OrganizationAffiliation' | 'Parameters' | 'Patient' | 'PaymentNotice' | 'PaymentReconciliation' | 'Person' | 'PlanDefinition' | 'Practitioner' | 'PractitionerRole' | 'Procedure' | 'Provenance' | 'Questionnaire' | 'QuestionnaireResponse' | 'RelatedPerson' | 'RequestGroup' | 'ResearchDefinition' | 'ResearchElementDefinition' | 'ResearchStudy' | 'ResearchSubject' | 'RiskAssessment' | 'RiskEvidenceSynthesis' | 'Schedule' | 'SearchParameter' | 'ServiceRequest' | 'Slot' | 'Specimen' | 'SpecimenDefinition' | 'StructureDefinition' | 'StructureMap' | 'Subscription' | 'Substance' | 'SubstanceNucleicAcid' | 'SubstancePolymer' | 'SubstanceProtein' | 'SubstanceReferenceInformation' | 'SubstanceSourceMaterial' | 'SubstanceSpecification' | 'SupplyDelivery' | 'SupplyRequest' | 'Task' | 'TerminologyCapabilities' | 'TestReport' | 'TestScript' | 'ValueSet' | 'VerificationResult' | 'VisionPrescription';
+export interface SourceQuery extends Extension {
+    url: 'http://hl7.org/fhir/uv/sdc/StructureDefinition/sdc-questionnaire-sourceQueries';
+    valueReference: Reference;
+}
+export interface QuestionnaireLevelXFhirQueryVariable extends Extension {
+    url: 'http://hl7.org/fhir/StructureDefinition/variable';
+    valueExpression: XFhirQueryVariableExpression;
+}
+interface XFhirQueryVariableExpression extends Expression {
+    name: string;
+    language: 'application/x-fhir-query';
+    expression: string;
+}
+export {};

package/dist/interfaces/questionnaireStore.interface.d.ts

@@ -0,0 +1,18 @@
+import type { Tabs } from 'smart-forms-app/src/features/renderer/types/tab.interface';
+import type { Variables } from './variables.interface';
+import type { LaunchContext } from './populate.interface';
+import type { EnableWhenExpression, EnableWhenItemProperties } from './enableWhen.interface';
+import type { CalculatedExpression } from './calculatedExpression.interface';
+import type { AnswerExpression } from './answerExpression.interface';
+import type { Coding } from 'fhir/r4';
+export interface QuestionnaireModel {
+    tabs: Tabs;
+    variables: Variables;
+    launchContexts: Record<string, LaunchContext>;
+    enableWhenItems: Record<string, EnableWhenItemProperties>;
+    enableWhenExpressions: Record<string, EnableWhenExpression>;
+    calculatedExpressions: Record<string, CalculatedExpression>;
+    answerExpressions: Record<string, AnswerExpression>;
+    processedValueSetCodings: Record<string, Coding[]>;
+    processedValueSetUrls: Record<string, string>;
+}

package/dist/interfaces/regex.interface.d.ts

@@ -0,0 +1,4 @@
+export interface RegexValidation {
+    expression: RegExp;
+    feedback: string | null;
+}

package/dist/interfaces/renderProps.interface.d.ts

@@ -0,0 +1,13 @@
+import type { QrRepeatGroup } from './repeatGroup.interface.ts';
+export interface PropsWithQrItemChangeHandler<QuestionnaireResponseItem> {
+    onQrItemChange: (qrItem: QuestionnaireResponseItem) => unknown;
+}
+export interface PropsWithQrRepeatGroupChangeHandler {
+    onQrRepeatGroupChange: (qrRepeatGroup: QrRepeatGroup) => unknown;
+}
+export interface PropsWithIsRepeatedAttribute {
+    isRepeated: boolean;
+}
+export interface PropsWithIsTabledAttribute {
+    isTabled: boolean;
+}

package/dist/interfaces/repeatGroup.interface.d.ts

@@ -0,0 +1,9 @@
+import type { QuestionnaireResponseItem } from 'fhir/r4';
+export interface QrRepeatGroup {
+    linkId: string;
+    qrItems: QuestionnaireResponseItem[];
+}
+export interface RepeatGroupSingle {
+    nanoId: string;
+    qrItem: QuestionnaireResponseItem | null;
+}

package/dist/interfaces/repeatItem.interface.d.ts

@@ -0,0 +1,5 @@
+import type { QuestionnaireResponseItemAnswer } from 'fhir/r4';
+export interface RepeatAnswer {
+    nanoId: string;
+    answer: QuestionnaireResponseItemAnswer | null;
+}

package/dist/interfaces/tab.interface.d.ts

@@ -0,0 +1,6 @@
+export type Tab = {
+    tabIndex: number;
+    isComplete: boolean;
+    isHidden: boolean;
+};
+export type Tabs = Record<string, Tab>;

package/dist/interfaces/valueSet.interface.d.ts

@@ -0,0 +1,5 @@
+import type { ValueSet } from 'fhir/r4';
+export interface ValueSetPromise {
+    promise: Promise<ValueSet>;
+    valueSet?: ValueSet;
+}

package/dist/interfaces/variables.interface.d.ts

@@ -0,0 +1,9 @@
+import type { Expression, FhirResource } from 'fhir/r4';
+export interface Variables {
+    fhirPathVariables: Record<string, Expression[]>;
+    xFhirQueryVariables: Record<string, VariableXFhirQuery>;
+}
+export interface VariableXFhirQuery {
+    valueExpression: Expression;
+    result?: FhirResource;
+}

package/dist/setup-jest.d.ts

@@ -0,0 +1 @@
+import '@testing-library/jest-dom';

package/dist/stores/useConfigStore.d.ts

@@ -0,0 +1,18 @@
+import type { Encounter, Patient, Practitioner, Questionnaire } from 'fhir/r4';
+import type Client from 'fhirclient/lib/Client';
+export interface ConfigState {
+    smartClient: Client | null;
+    patient: Patient | null;
+    user: Practitioner | null;
+    encounter: Encounter | null;
+    launchQuestionnaire: Questionnaire | null;
+    debugMode: boolean;
+    setSmartClient: (client: Client) => void;
+    setPatient: (patient: Patient) => void;
+    setUser: (user: Practitioner) => void;
+    setEncounter: (encounter: Encounter) => void;
+    setLaunchQuestionnaire: (launchQuestionnaire: Questionnaire | null) => void;
+    activateDebugMode: () => void;
+}
+declare const useConfigStore: import("zustand").UseBoundStore<import("zustand").StoreApi<ConfigState>>;
+export default useConfigStore;

package/dist/stores/useQuestionnaireResponseStore.d.ts

@@ -0,0 +1,14 @@
+import type { QuestionnaireResponse } from 'fhir/r4';
+export interface UseQuestionnaireResponseStoreType {
+    sourceResponse: QuestionnaireResponse;
+    updatableResponse: QuestionnaireResponse;
+    hasChanges: boolean;
+    buildSourceResponse: (response: QuestionnaireResponse) => void;
+    populateResponse: (response: QuestionnaireResponse) => void;
+    updateResponse: (updatedResponse: QuestionnaireResponse) => void;
+    saveResponse: (savedResponse: QuestionnaireResponse) => void;
+    clearResponse: (clearedResponse: QuestionnaireResponse) => void;
+    destroySourceResponse: () => void;
+}
+declare const useQuestionnaireResponseStore: import("zustand").UseBoundStore<import("zustand").StoreApi<UseQuestionnaireResponseStoreType>>;
+export default useQuestionnaireResponseStore;

package/dist/stores/useQuestionnaireStore.d.ts

@@ -0,0 +1,34 @@
+import type { Coding, Questionnaire, QuestionnaireResponse, QuestionnaireResponseItemAnswer } from 'fhir/r4';
+import type { Variables } from '../interfaces/variables.interface';
+import type { LaunchContext } from '../interfaces/populate.interface';
+import type { CalculatedExpression } from '../interfaces/calculatedExpression.interface';
+import type { EnableWhenExpression, EnableWhenItems } from '../interfaces/enableWhen.interface';
+import type { AnswerExpression } from '../interfaces/answerExpression.interface';
+import type { Tabs } from '../interfaces/tab.interface';
+export interface UseQuestionnaireStoreType {
+    sourceQuestionnaire: Questionnaire;
+    tabs: Tabs;
+    currentTabIndex: number;
+    variables: Variables;
+    launchContexts: Record<string, LaunchContext>;
+    enableWhenItems: EnableWhenItems;
+    enableWhenLinkedQuestions: Record<string, string[]>;
+    enableWhenIsActivated: boolean;
+    enableWhenExpressions: Record<string, EnableWhenExpression>;
+    calculatedExpressions: Record<string, CalculatedExpression>;
+    answerExpressions: Record<string, AnswerExpression>;
+    processedValueSetCodings: Record<string, Coding[]>;
+    processedValueSetUrls: Record<string, string>;
+    cachedValueSetCodings: Record<string, Coding[]>;
+    buildSourceQuestionnaire: (questionnaire: Questionnaire, questionnaireResponse?: QuestionnaireResponse, additionalVariables?: Record<string, object>) => Promise<void>;
+    destroySourceQuestionnaire: () => void;
+    switchTab: (newTabIndex: number) => void;
+    markTabAsComplete: (tabLinkId: string) => void;
+    updateEnableWhenItem: (linkId: string, newAnswer: QuestionnaireResponseItemAnswer[]) => void;
+    toggleEnableWhenActivation: (isActivated: boolean) => void;
+    updateExpressions: (updatedResponse: QuestionnaireResponse) => void;
+    addCodingToCache: (valueSetUrl: string, codings: Coding[]) => void;
+    updatePopulatedProperties: (populatedResponse: QuestionnaireResponse) => QuestionnaireResponse;
+}
+declare const useQuestionnaireStore: import("zustand").UseBoundStore<import("zustand").StoreApi<UseQuestionnaireStoreType>>;
+export default useQuestionnaireStore;

package/dist/stories/FormRendererWrapper.stories.d.ts

@@ -0,0 +1,11 @@
+import type { StoryObj } from '@storybook/react';
+import type { SmartFormsRenderer } from '../components';
+declare const meta: {
+    title: string;
+    component: typeof SmartFormsRenderer;
+    tags: string[];
+};
+export default meta;
+type Story = StoryObj<typeof meta>;
+export declare const ItemWithoutResponse: Story;
+export declare const ItemWithResponse: Story;

package/dist/stories/SmartFormsRenderer.stories.d.ts

@@ -0,0 +1,14 @@
+import type { StoryObj } from '@storybook/react';
+import { SmartFormsRenderer } from '../components';
+declare const meta: {
+    title: string;
+    component: typeof SmartFormsRenderer;
+    tags: string[];
+};
+export default meta;
+type Story = StoryObj<typeof meta>;
+export declare const Form715: Story;
+export declare const Form715WithResponse: Story;
+export declare const FormTestGrid: Story;
+export declare const FormTestGridWithResponse: Story;
+export declare const QTestGridWithResponseAddFhirPath: Story;

package/dist/utils/calculatedExpression.d.ts

@@ -0,0 +1,14 @@
+import type { CalculatedExpression } from '../interfaces/calculatedExpression.interface';
+import type { Expression, Questionnaire, QuestionnaireResponse } from 'fhir/r4';
+interface EvaluateInitialCalculatedExpressionsParams {
+    initialResponse: QuestionnaireResponse;
+    calculatedExpressions: Record<string, CalculatedExpression>;
+    variablesFhirPath: Record<string, Expression[]>;
+}
+export declare function evaluateInitialCalculatedExpressions(params: EvaluateInitialCalculatedExpressionsParams): Record<string, CalculatedExpression>;
+export declare function evaluateCalculatedExpressions(fhirPathContext: Record<string, any>, calculatedExpressions: Record<string, CalculatedExpression>): {
+    calculatedExpsIsUpdated: boolean;
+    updatedCalculatedExpressions: Record<string, CalculatedExpression>;
+};
+export declare function initialiseCalculatedExpressionValues(questionnaire: Questionnaire, populatedResponse: QuestionnaireResponse, calculatedExpressions: Record<string, CalculatedExpression>): QuestionnaireResponse;
+export {};

package/dist/utils/choice.d.ts

@@ -0,0 +1,44 @@
+import type { Coding, QuestionnaireItem, QuestionnaireItemAnswerOption, QuestionnaireResponseItem, QuestionnaireResponseItemAnswer } from 'fhir/r4';
+import { QItemChoiceControl, QItemChoiceOrientation } from '../interfaces/choice.enum';
+/**
+ * Get choice control type based on certain criteria in choice items
+ *
+ * @author Sean Fong
+ */
+export declare function getChoiceControlType(qItem: QuestionnaireItem): QItemChoiceControl;
+/**
+ * Find and return corresponding answerOption based on selected answer in form
+ *
+ * @author Sean Fong
+ */
+export declare function findInAnswerOptions(answerOptions: QuestionnaireItemAnswerOption[], selected: string): QuestionnaireResponseItemAnswer | undefined;
+/**
+ * Find and return corresponding coding from AnswerValyeSet based on selected answer in form
+ *
+ * @author Sean Fong
+ */
+export declare function findInAnswerValueSetCodings(codings: Coding[], selected: string): QuestionnaireResponseItemAnswer | undefined;
+/**
+ * Find and return string value from selected answer
+ *
+ * @author Sean Fong
+ */
+export declare function getQrChoiceValue(qrChoice: QuestionnaireResponseItem, returnNull?: boolean): string | null;
+/**
+ * Update choice checkbox group answers based on checkbox changes
+ *
+ * @author Sean Fong
+ */
+export declare function updateQrCheckboxAnswers(changedValue: string, answers: QuestionnaireResponseItemAnswer[], answerOptions: QuestionnaireItemAnswerOption[], qrChoiceCheckbox: QuestionnaireResponseItem, isMultiSelection: boolean): QuestionnaireResponseItem | null;
+/**
+ * Get choice orientation from its itemControl
+ *
+ * @author Sean Fong
+ */
+export declare function getChoiceOrientation(qItem: QuestionnaireItem): QItemChoiceOrientation;
+/**
+ * Converts an array of codings to an array of valueCodings which can use the QuestionnaireItemAnswerOption type
+ *
+ * @author Sean Fong
+ */
+export declare function mapCodingsToOptions(codings: Coding[]): QuestionnaireItemAnswerOption[];

package/dist/utils/debounce.d.ts

@@ -0,0 +1,2 @@
+export declare const DEBOUNCE_DURATION = 200;
+export declare const AUTOCOMPLETE_DEBOUNCE_DURATION = 300;

package/dist/utils/emptyResource.d.ts

@@ -0,0 +1,3 @@
+import type { Questionnaire, QuestionnaireResponse } from 'fhir/r4';
+export declare const emptyQuestionnaire: Questionnaire;
+export declare const emptyResponse: QuestionnaireResponse;

package/dist/utils/enableWhen.d.ts

@@ -0,0 +1,47 @@
+import type { QuestionnaireItemEnableWhen, QuestionnaireResponse, QuestionnaireResponseItemAnswer } from 'fhir/r4';
+import type { EnableWhenItemProperties, EnableWhenItems } from '../interfaces/enableWhen.interface';
+/**
+ * Create a linkedQuestionsMap that contains linked items of enableWhen items
+ * mapped to an array containing all its respective enableWhen items' linkIds
+ * returns a key-value pair of <linkedItemId, [enableWhenItem1LinkId, enableWhenItem2LinkId, enableWhenItem3LinkId]>
+ *
+ * @author Sean Fong
+ */
+export declare function createEnableWhenLinkedQuestions(enableWhenItems: EnableWhenItems): Record<string, string[]>;
+/**
+ * Performs switching for non-group enableWhenItems based on their item types.
+ *
+ * @author Sean Fong
+ */
+export declare function isEnabledAnswerTypeSwitcher(enableWhen: QuestionnaireItemEnableWhen, answer: QuestionnaireResponseItemAnswer): boolean;
+/**
+ * Read initial answer values in questionnaireResponse
+ * return a map of initial values with key-value pair <linkedItemId, initial value>
+ *
+ * @author Sean Fong
+ */
+export declare function readInitialAnswers(questionnaireResponse: QuestionnaireResponse, linkedQuestionsMap: Record<string, string[]>): Record<string, QuestionnaireResponseItemAnswer[]>;
+/**
+ * Set initial answer values into enableWhenItems' answer attributes
+ * Update enabled status of each enableWhenItem simultaneously
+ *
+ * @author Sean Fong
+ */
+export declare function setInitialAnswers(initialAnswers: Record<string, QuestionnaireResponseItemAnswer[]>, items: EnableWhenItems, linkedQuestionsMap: Record<string, string[]>): EnableWhenItems;
+/**
+ * Update answer of the target linkId in every related enableWhenItem's linked items
+ * Then update the enabled status of every related enableWhenItem
+ *
+ * @author Sean Fong
+ */
+export declare function updateItemAnswer(items: EnableWhenItems, linkedQuestions: string[], linkId: string, newAnswer: QuestionnaireResponseItemAnswer[]): EnableWhenItems;
+/**
+ * Check if an enableWhenItem is enabled based on the answer of its linked items
+ *
+ * @author Sean Fong
+ */
+export declare function checkItemIsEnabled(enableWhenItemProperties: EnableWhenItemProperties): boolean;
+export declare function assignPopulatedAnswersToEnableWhen(items: EnableWhenItems, questionnaireResponse: QuestionnaireResponse): {
+    initialisedItems: EnableWhenItems;
+    linkedQuestions: Record<string, string[]>;
+};

package/dist/utils/enableWhenExpression.d.ts

@@ -0,0 +1,13 @@
+import type { EnableWhenExpression } from '../interfaces/enableWhen.interface';
+import type { Expression, QuestionnaireResponse } from 'fhir/r4';
+interface EvaluateInitialEnableWhenExpressionsParams {
+    initialResponse: QuestionnaireResponse;
+    enableWhenExpressions: Record<string, EnableWhenExpression>;
+    variablesFhirPath: Record<string, Expression[]>;
+}
+export declare function evaluateInitialEnableWhenExpressions(params: EvaluateInitialEnableWhenExpressionsParams): Record<string, EnableWhenExpression>;
+export declare function evaluateEnableWhenExpressions(fhirPathContext: Record<string, any>, enableWhenExpressions: Record<string, EnableWhenExpression>): {
+    enableWhenExpsIsUpdated: boolean;
+    updatedEnableWhenExpressions: Record<string, EnableWhenExpression>;
+};
+export {};

package/dist/utils/fhirpath.d.ts

@@ -0,0 +1,19 @@
+import type { Expression, QuestionnaireResponse, QuestionnaireResponseItem } from 'fhir/r4';
+import type { CalculatedExpression } from '../interfaces/calculatedExpression.interface';
+import type { EnableWhenExpression } from '../interfaces/enableWhen.interface';
+interface EvaluateUpdatedExpressionsParams {
+    updatedResponse: QuestionnaireResponse;
+    calculatedExpressions: Record<string, CalculatedExpression>;
+    enableWhenExpressions: Record<string, EnableWhenExpression>;
+    variablesFhirPath: Record<string, Expression[]>;
+}
+export declare function evaluateUpdatedExpressions(params: EvaluateUpdatedExpressionsParams): {
+    isUpdated: boolean;
+    updatedEnableWhenExpressions: Record<string, EnableWhenExpression>;
+    updatedCalculatedExpressions: Record<string, CalculatedExpression>;
+};
+export declare function createFhirPathContext(questionnaireResponse: QuestionnaireResponse, variablesFhirPath: Record<string, Expression[]>): Record<string, any>;
+export declare function evaluateFhirPathRecursive(item: QuestionnaireResponseItem, variablesFhirPath: Record<string, Expression[]>, fhirPathContext: Record<string, any>): void;
+export declare function evaluateItemFhirPath(item: QuestionnaireResponseItem, variablesFhirPath: Record<string, Expression[]>, fhirPathContext: Record<string, any>): void;
+export declare function evaluateResourceLevelFhirPath(resource: QuestionnaireResponse, variablesFhirPath: Record<string, Expression[]>, fhirPathContext: Record<string, any>): void;
+export {};

package/dist/utils/initialiseForm.d.ts

@@ -0,0 +1,20 @@
+import type { Expression, QuestionnaireResponse } from 'fhir/r4';
+import type { EnableWhenExpression, EnableWhenItems } from '../interfaces/enableWhen.interface';
+import type { Tabs } from '../interfaces/tab.interface';
+import type { CalculatedExpression } from '../interfaces/calculatedExpression.interface';
+interface initialFormFromResponseParams {
+    questionnaireResponse: QuestionnaireResponse;
+    enableWhenItems: EnableWhenItems;
+    enableWhenExpressions: Record<string, EnableWhenExpression>;
+    calculatedExpressions: Record<string, CalculatedExpression>;
+    variablesFhirPath: Record<string, Expression[]>;
+    tabs: Tabs;
+}
+export declare function initialiseFormFromResponse(params: initialFormFromResponseParams): {
+    initialEnableWhenItems: EnableWhenItems;
+    initialEnableWhenLinkedQuestions: Record<string, string[]>;
+    initialEnableWhenExpressions: Record<string, EnableWhenExpression>;
+    initialCalculatedExpressions: Record<string, CalculatedExpression>;
+    firstVisibleTab: number;
+};
+export {};

package/dist/utils/itemControl.d.ts

@@ -0,0 +1,108 @@
+import type { Expression, Extension, QuestionnaireItem, QuestionnaireResponse } from 'fhir/r4';
+import type { RegexValidation } from '../interfaces/regex.interface';
+/**
+ * Check if the extension has an itemControl code equal to the given itemControlCode
+ *
+ * @author Sean Fong
+ */
+export declare function isSpecificItemControl(qItem: QuestionnaireItem, itemControlCode: string): boolean;
+/**
+ * Check if the extension has an displayCategory code equal to the given displayCategory
+ *
+ * @author Sean Fong
+ */
+export declare function isSpecificDisplayCategory(qItem: QuestionnaireItem, itemControlCode: string): boolean;
+/**
+ * Check if the extension has url for items that use shortText
+ *
+ * @author Sean Fong
+ */
+export declare function getShortText(qItem: QuestionnaireItem): string | null;
+/**
+ * Check if the extension has url for hidden questions
+ *
+ * @author Sean Fong
+ */
+export declare function hasHiddenExtension(qItem: QuestionnaireItem): boolean;
+/**
+ * Check if an answerExpression extension is present
+ *
+ * @author Sean Fong
+ */
+export declare function getAnswerExpression(qItem: QuestionnaireItem): Expression | null;
+/**
+ * Check if the extension has url for items that use open label
+ *
+ * @author Sean Fong
+ */
+export declare function getOpenLabelText(qItem: QuestionnaireItem): string | null;
+/**
+ * Check if the decimal value has a quantity precision for the decimal value
+ *
+ * @author Sean Fong
+ */
+export declare function getDecimalPrecision(qItem: QuestionnaireItem): number | null;
+/**
+ * Check if the extension has a url for xhtml rendering
+ *
+ * @author Sean Fong
+ */
+export declare function getXHtmlString(qItem: QuestionnaireItem): string | null;
+export declare function getXHtmlStringFromExtension(extensions: Extension[]): string | null;
+/**
+ * Check if the item label (text) has a valueMarkdown extension
+ *
+ * @author Sean Fong
+ */
+export declare function getMarkdownString(qItem: QuestionnaireItem): string | null;
+/**
+ * Get questionnaire name from questionnaireResponse
+ * If questionnaireResponse does not have a name, fallback to questionnaireResponse questionnaireId
+ *
+ * @author Sean Fong
+ */
+export declare function getQuestionnaireNameFromResponse(questionnaireResponse: QuestionnaireResponse): string;
+/**
+ * Get text display prompt for items with itemControlCode prompt and has a prompt childItem
+ *
+ * @author Sean Fong
+ */
+export declare function getTextDisplayPrompt(qItem: QuestionnaireItem): string;
+/**
+ * Check if item is readonly
+ *
+ * @author Sean Fong
+ */
+export declare function getReadOnly(qItem: QuestionnaireItem): boolean;
+/**
+ * Get decimal text display unit for items with itemControlCode unit and has a unit childItem
+ *
+ * @author Sean Fong
+ */
+export declare function getTextDisplayUnit(qItem: QuestionnaireItem): string;
+/**
+ * Get text display instructions for items with itemControlCode instructions and has an instructions childItem
+ *
+ * @author Sean Fong
+ */
+export declare function getTextDisplayInstructions(qItem: QuestionnaireItem): string;
+/**
+ * Get entry format if its extension is present
+ * i.e. DD-MM-YYYY for dates, HH:MM for times etc.
+ *
+ * @author Sean Fong
+ */
+export declare function getEntryFormat(qItem: QuestionnaireItem): string;
+/**
+ * Get entry format if its extension is present
+ * i.e. DD-MM-YYYY for dates, HH:MM for times etc.
+ *
+ * @author Sean Fong
+ */
+export declare function getRegexValidation(qItem: QuestionnaireItem): RegexValidation | null;
+/**
+ * Get maximum length of characters allowed if present
+ *
+ * @author Sean Fong
+ */
+export declare function getMaxLength(qItem: QuestionnaireItem): number | null;

package/dist/utils/mapItem.d.ts

@@ -0,0 +1,18 @@
+import type { QuestionnaireItem, QuestionnaireResponseItem } from 'fhir/r4';
+/**
+ * Generate an array of QuestionnaireResponseItems corresponding to its QuestionnaireItem indexes an array.
+ * QuestionnaireItems without a corresponding QuestionnaireResponseItem is set as undefined.
+ * i.e. QItems = [QItem0, QItem1, QItem2]. Only QItem0 and QItem2 have QrItems
+ * Generated array: [QrItem0, undefined, QrItem2]
+ *
+ * @author Sean Fong
+ */
+export declare function getQrItemsIndex(qItems: QuestionnaireItem[], qrItems: QuestionnaireResponseItem[], qItemsIndexMap: Record<string, number>): (QuestionnaireResponseItem | QuestionnaireResponseItem[])[];
+/**
+ * Generate a dictionary of QuestionnaireItems linkIds mapped to their respective array indexes <linkId, QItemIndex>
+ * i.e. { ee2589d5: 0, f9aaa187: 1, 88cab112: 2 }
+ * where ee2589d5, f9aaa187 and 88cab112 are linkIds of QItem0, QItem1 and QItem2 respectively
+ *
+ * @author Sean Fong
+ */
+export declare function mapQItemsIndex(qGroup: QuestionnaireItem): Record<string, number>;

package/dist/utils/openChoice.d.ts

@@ -0,0 +1,22 @@
+import type { Coding, QuestionnaireItem, QuestionnaireItemAnswerOption, QuestionnaireResponseItem, QuestionnaireResponseItemAnswer } from 'fhir/r4';
+import { CheckBoxOptionType, QItemOpenChoiceControl } from '../interfaces/choice.enum';
+/**
+ * Update open-choice checkbox group answers based on checkbox changes
+ *
+ * @author Sean Fong
+ */
+export declare function updateQrOpenChoiceCheckboxAnswers(changedOptionAnswer: string | null, changedOpenLabelAnswer: string | null, answers: QuestionnaireResponseItemAnswer[], answerOptions: QuestionnaireItemAnswerOption[] | Coding[], qrChoiceCheckbox: QuestionnaireResponseItem, checkboxOptionType: CheckBoxOptionType, isMultiSelection: boolean): QuestionnaireResponseItem | null;
+export declare function getOldOpenLabelAnswer(answers: QuestionnaireResponseItemAnswer[], options: QuestionnaireItemAnswerOption[]): QuestionnaireResponseItemAnswer | null;
+/**
+ * Get openChoice control type from qItem
+ * defaults to select if no control code is provided
+ *
+ * @author Sean Fong
+ */
+export declare function getOpenChoiceControlType(qItem: QuestionnaireItem): QItemOpenChoiceControl;
+/**
+ * Get string label from given answerOption
+ *
+ * @author Sean Fong
+ */
+export declare function getAnswerOptionLabel(option: QuestionnaireItemAnswerOption | string): string;

package/dist/utils/parseInputs.d.ts

@@ -0,0 +1,4 @@
+export declare function parseValidInteger(input: string): number;
+export declare function parseValidNumericString(input: string): string;
+export declare function parseDecimalStringWithPrecision(input: string, precision: number | null): string;
+export declare function parseDecimalStringToFloat(input: string, precision: number): number;

package/dist/utils/populate.d.ts

@@ -0,0 +1,16 @@
+import type { Encounter, Patient, Practitioner, Questionnaire, QuestionnaireResponse } from 'fhir/r4';
+import type Client from 'fhirclient/lib/Client';
+export interface PopulateFormParams {
+    populated: QuestionnaireResponse;
+    hasWarnings: boolean;
+}
+/**
+ * Pre-populate questionnaire from CMS patient data to form a populated questionnaireResponse
+ *
+ * @author Sean Fong
+ */
+export declare function populateQuestionnaire(questionnaire: Questionnaire, fhirClient: Client, patient: Patient, user: Practitioner, encounter: Encounter | null, populateForm: {
+    (params: PopulateFormParams): void;
+}, exitSpinner: {
+    (): void;
+}): Promise<void>;