@welshare/questionnaire 0.1.0

package/dist/esm/components/questions/integer-question.js

@@ -0,0 +1,24 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * Renders an integer question with optional slider control
+ */
+export const IntegerQuestion = ({ item, currentAnswer, onIntegerChange, inputClassName = "", sliderConfig, }) => {
+    // Render slider if slider config is present
+    if (sliderConfig) {
+        // Use current answer, or fallback to initial value, or fallback to minValue
+        const initialValue = item.initial?.[0]?.valueInteger;
+        const value = currentAnswer?.valueInteger ?? initialValue ?? sliderConfig.minValue;
+        const unit = sliderConfig.unit || "";
+        // Create abbreviated unit for range labels
+        const unitShort = unit === "minutes"
+            ? "min"
+            : unit === "hours"
+                ? "hr"
+                : unit === "days per week"
+                    ? "days"
+                    : unit;
+        return (_jsxs("div", { className: "wq-question-slider", children: [_jsx("input", { type: "range", className: `wq-slider-input ${inputClassName}`, min: sliderConfig.minValue, max: sliderConfig.maxValue, step: sliderConfig.step, value: value, onChange: (e) => onIntegerChange(e.target.value) }), _jsxs("div", { className: "wq-slider-value-display", children: [_jsx("span", { className: "wq-slider-value", children: value }), unit && _jsx("span", { className: "wq-slider-unit", children: unit })] }), _jsxs("div", { className: "wq-slider-range-labels", children: [_jsxs("span", { className: "wq-slider-min", children: [sliderConfig.minValue, unitShort && ` ${unitShort}`] }), _jsxs("span", { className: "wq-slider-max", children: [sliderConfig.maxValue, unitShort && ` ${unitShort}`] })] })] }));
+    }
+    // Default number input
+    return (_jsx("input", { type: "number", className: `wq-question-input ${inputClassName}`, value: currentAnswer?.valueInteger ?? "", onChange: (e) => onIntegerChange(e.target.value), placeholder: "Enter a number", step: "1" }));
+};

package/dist/esm/components/questions/multiple-choice-question.d.ts

@@ -0,0 +1,20 @@
+import { type ReactNode } from "react";
+import type { QuestionnaireItem, QuestionnaireResponseAnswer } from "../../types/fhir.js";
+import { CheckboxInputProps } from "../../types/index.js";
+export interface MultipleChoiceQuestionProps {
+    item: QuestionnaireItem;
+    currentAnswers: QuestionnaireResponseAnswer[];
+    onMultipleChoiceToggle: (valueCoding: {
+        system?: string;
+        code?: string;
+        display?: string;
+    }, valueInteger?: number) => void;
+    choiceClassName?: string;
+    renderCheckboxInput?: (props: CheckboxInputProps) => ReactNode;
+}
+/**
+ * Renders a multi-select choice question with checkboxes
+ * Supports exclusive options and maxAnswers limits
+ */
+export declare const MultipleChoiceQuestion: ({ item, currentAnswers, onMultipleChoiceToggle, choiceClassName, renderCheckboxInput, }: MultipleChoiceQuestionProps) => import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=multiple-choice-question.d.ts.map

package/dist/esm/components/questions/multiple-choice-question.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"multiple-choice-question.d.ts","sourceRoot":"","sources":["../../../../src/components/questions/multiple-choice-question.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,SAAS,EAAE,MAAM,OAAO,CAAC;AACvC,OAAO,KAAK,EACV,iBAAiB,EACjB,2BAA2B,EAC5B,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAE1D,MAAM,WAAW,2BAA2B;IAC1C,IAAI,EAAE,iBAAiB,CAAC;IACxB,cAAc,EAAE,2BAA2B,EAAE,CAAC;IAC9C,sBAAsB,EAAE,CACtB,WAAW,EAAE;QAAE,MAAM,CAAC,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,CAAA;KAAE,EACjE,YAAY,CAAC,EAAE,MAAM,KAClB,IAAI,CAAC;IACV,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,mBAAmB,CAAC,EAAE,CAAC,KAAK,EAAE,kBAAkB,KAAK,SAAS,CAAC;CAChE;AAED;;;GAGG;AACH,eAAO,MAAM,sBAAsB,GAAI,yFAMpC,2BAA2B,4CA0F7B,CAAC"}

package/dist/esm/components/questions/multiple-choice-question.js

@@ -0,0 +1,39 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * Renders a multi-select choice question with checkboxes
+ * Supports exclusive options and maxAnswers limits
+ */
+export const MultipleChoiceQuestion = ({ item, currentAnswers, onMultipleChoiceToggle, choiceClassName = "", renderCheckboxInput, }) => {
+    const maxAnswers = item.maxAnswers || Number.MAX_SAFE_INTEGER;
+    const atMaxAnswers = currentAnswers.length >= maxAnswers;
+    // Check if there's an exclusive option extension
+    const exclusiveOptionExt = item.extension?.find((ext) => ext.url ===
+        "http://codes.welshare.app/StructureDefinition/questionnaire-exclusive-option");
+    const exclusiveOptionCode = exclusiveOptionExt?.valueString;
+    // Check if the exclusive option is currently selected
+    const exclusiveSelected = exclusiveOptionCode &&
+        currentAnswers.some((answer) => answer.valueCoding?.code === exclusiveOptionCode);
+    // Filter options to show: if exclusive option is selected, only show that one
+    const optionsToShow = exclusiveSelected
+        ? item.answerOption?.filter((opt) => opt.valueCoding?.code === exclusiveOptionCode)
+        : item.answerOption;
+    return (_jsxs("div", { className: `wq-question-choice ${choiceClassName}`, children: [optionsToShow?.map((option, index) => {
+                const isSelected = currentAnswers.some((answer) => answer.valueCoding?.code === option.valueCoding?.code);
+                const isDisabled = !isSelected && atMaxAnswers;
+                // Use custom renderer if provided
+                if (renderCheckboxInput) {
+                    return (_jsx("div", { children: renderCheckboxInput({
+                            linkId: item.linkId,
+                            valueCoding: option.valueCoding,
+                            valueInteger: option.valueInteger,
+                            checked: isSelected,
+                            disabled: isDisabled,
+                            onChange: () => onMultipleChoiceToggle(option.valueCoding || {}, option.valueInteger),
+                            label: option.valueCoding?.display || "",
+                            index,
+                        }) }, index));
+                }
+                // Default rendering
+                return (_jsxs("label", { className: `wq-choice-option ${isSelected ? "wq-selected" : ""} ${isDisabled ? "wq-disabled" : ""}`, children: [_jsx("input", { type: "checkbox", name: item.linkId, value: option.valueCoding?.code, checked: isSelected, disabled: isDisabled, onChange: () => onMultipleChoiceToggle(option.valueCoding || {}, option.valueInteger), "data-wq-input": "checkbox", "data-wq-selected": isSelected }), _jsx("span", { className: "wq-choice-label", children: option.valueCoding?.display })] }, index));
+            }), item.maxAnswers && (_jsxs("div", { className: "wq-max-answers-hint", children: ["Selected: ", currentAnswers.length, " / ", item.maxAnswers] }))] }));
+};

package/dist/esm/components/questions/string-question.d.ts

@@ -0,0 +1,12 @@
+import type { QuestionnaireItem, QuestionnaireResponseAnswer } from "../../types/fhir.js";
+export interface StringQuestionProps {
+    item: QuestionnaireItem;
+    currentAnswer?: QuestionnaireResponseAnswer;
+    onStringChange: (value: string) => void;
+    inputClassName?: string;
+}
+/**
+ * Renders a string or text question with text input
+ */
+export declare const StringQuestion: ({ item, currentAnswer, onStringChange, inputClassName, }: StringQuestionProps) => import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=string-question.d.ts.map

package/dist/esm/components/questions/string-question.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"string-question.d.ts","sourceRoot":"","sources":["../../../../src/components/questions/string-question.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,iBAAiB,EACjB,2BAA2B,EAC5B,MAAM,qBAAqB,CAAC;AAE7B,MAAM,WAAW,mBAAmB;IAClC,IAAI,EAAE,iBAAiB,CAAC;IACxB,aAAa,CAAC,EAAE,2BAA2B,CAAC;IAC5C,cAAc,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IACxC,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAED;;GAEG;AACH,eAAO,MAAM,cAAc,GAAI,0DAK5B,mBAAmB,4CAUrB,CAAC"}

package/dist/esm/components/questions/string-question.js

@@ -0,0 +1,7 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/**
+ * Renders a string or text question with text input
+ */
+export const StringQuestion = ({ item, currentAnswer, onStringChange, inputClassName = "", }) => {
+    return (_jsx("input", { type: "text", className: `wq-question-input ${inputClassName}`, value: currentAnswer?.valueString ?? "", onChange: (e) => onStringChange(e.target.value), placeholder: "Enter your answer" }));
+};

package/dist/esm/contexts/questionnaire-context.d.ts

@@ -0,0 +1,41 @@
+import { type ReactNode } from "react";
+import type { Questionnaire, QuestionnaireItem, QuestionnaireResponse, QuestionnaireResponseAnswer } from "../types/fhir.js";
+export interface QuestionnaireContextType {
+    questionnaire: Questionnaire;
+    response: QuestionnaireResponse;
+    updateAnswer: (linkId: string, answer: QuestionnaireResponseAnswer) => void;
+    updateMultipleAnswers: (linkId: string, answers: QuestionnaireResponseAnswer[]) => void;
+    getAnswer: (linkId: string) => QuestionnaireResponseAnswer | undefined;
+    getAnswers: (linkId: string) => QuestionnaireResponseAnswer[];
+    isPageValid: (pageItems: QuestionnaireItem[]) => boolean;
+    getRequiredQuestions: (pageItems: QuestionnaireItem[]) => QuestionnaireItem[];
+    getUnansweredRequiredQuestions: (pageItems: QuestionnaireItem[]) => QuestionnaireItem[];
+    markValidationErrors: (pageItems: QuestionnaireItem[]) => void;
+    clearValidationErrors: () => void;
+    hasValidationError: (linkId: string) => boolean;
+    debugMode: boolean;
+    toggleDebugMode: () => void;
+}
+export declare const useQuestionnaire: () => QuestionnaireContextType;
+export interface QuestionnaireProviderProps {
+    children: ReactNode;
+    /**
+     * The FHIR Questionnaire object to render
+     * Clients are responsible for loading/fetching this data
+     */
+    questionnaire: Questionnaire;
+    /**
+     * Optional questionnaire ID to use in the response
+     * If not provided, will use questionnaire.id
+     * If neither exists, an error will be thrown
+     */
+    questionnaireId?: string;
+    /**
+     * If true, initializes the response with a hierarchical structure matching the questionnaire
+     * If false, uses a flat structure
+     * @default true
+     */
+    useNestedStructure?: boolean;
+}
+export declare const QuestionnaireProvider: ({ children, questionnaire, questionnaireId, useNestedStructure, }: QuestionnaireProviderProps) => import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=questionnaire-context.d.ts.map

package/dist/esm/contexts/questionnaire-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"questionnaire-context.d.ts","sourceRoot":"","sources":["../../../src/contexts/questionnaire-context.tsx"],"names":[],"mappings":"AAAA,OAAO,EAKL,KAAK,SAAS,EACf,MAAM,OAAO,CAAC;AACf,OAAO,KAAK,EACV,aAAa,EACb,iBAAiB,EACjB,qBAAqB,EACrB,2BAA2B,EAE5B,MAAM,kBAAkB,CAAC;AAG1B,MAAM,WAAW,wBAAwB;IACvC,aAAa,EAAE,aAAa,CAAC;IAC7B,QAAQ,EAAE,qBAAqB,CAAC;IAChC,YAAY,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,2BAA2B,KAAK,IAAI,CAAC;IAC5E,qBAAqB,EAAE,CACrB,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,2BAA2B,EAAE,KACnC,IAAI,CAAC;IACV,SAAS,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,2BAA2B,GAAG,SAAS,CAAC;IACvE,UAAU,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,2BAA2B,EAAE,CAAC;IAC9D,WAAW,EAAE,CAAC,SAAS,EAAE,iBAAiB,EAAE,KAAK,OAAO,CAAC;IACzD,oBAAoB,EAAE,CAAC,SAAS,EAAE,iBAAiB,EAAE,KAAK,iBAAiB,EAAE,CAAC;IAC9E,8BAA8B,EAAE,CAC9B,SAAS,EAAE,iBAAiB,EAAE,KAC3B,iBAAiB,EAAE,CAAC;IACzB,oBAAoB,EAAE,CAAC,SAAS,EAAE,iBAAiB,EAAE,KAAK,IAAI,CAAC;IAC/D,qBAAqB,EAAE,MAAM,IAAI,CAAC;IAClC,kBAAkB,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,OAAO,CAAC;IAChD,SAAS,EAAE,OAAO,CAAC;IACnB,eAAe,EAAE,MAAM,IAAI,CAAC;CAC7B;AAMD,eAAO,MAAM,gBAAgB,gCAQ5B,CAAC;AAEF,MAAM,WAAW,0BAA0B;IACzC,QAAQ,EAAE,SAAS,CAAC;IACpB;;;OAGG;IACH,aAAa,EAAE,aAAa,CAAC;IAC7B;;;;OAIG;IACH,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB;;;;OAIG;IACH,kBAAkB,CAAC,EAAE,OAAO,CAAC;CAC9B;AAED,eAAO,MAAM,qBAAqB,GAAI,mEAKnC,0BAA0B,4CAoa5B,CAAC"}

package/dist/esm/contexts/questionnaire-context.js

@@ -0,0 +1,350 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useContext, useEffect, useState, } from "react";
+import { getAllQuestionsFromPage } from "../lib/questionnaire-utils.js";
+const QuestionnaireContext = createContext(undefined);
+export const useQuestionnaire = () => {
+    const context = useContext(QuestionnaireContext);
+    if (!context) {
+        throw new Error("useQuestionnaire must be used within QuestionnaireProvider");
+    }
+    return context;
+};
+export const QuestionnaireProvider = ({ children, questionnaire, questionnaireId, useNestedStructure = true, }) => {
+    const [response, setResponse] = useState({
+        resourceType: "QuestionnaireResponse",
+        status: "in-progress",
+        item: [],
+    });
+    const [validationErrors, setValidationErrors] = useState(new Set());
+    const [debugMode, setDebugMode] = useState(false);
+    const toggleDebugMode = () => {
+        setDebugMode((prev) => !prev);
+    };
+    // Determine the questionnaire ID to use
+    const effectiveQuestionnaireId = questionnaireId || questionnaire.id;
+    if (!effectiveQuestionnaireId) {
+        throw new Error("QuestionnaireProvider: questionnaireId prop or questionnaire.id must be provided");
+    }
+    // Initialize response structure when questionnaire or options change
+    useEffect(() => {
+        if (useNestedStructure) {
+            // Build response structure mirroring questionnaire hierarchy
+            const buildResponseStructure = (questionnaireItems) => {
+                if (!questionnaireItems)
+                    return [];
+                return questionnaireItems.map((item) => {
+                    const responseItem = {
+                        linkId: item.linkId,
+                    };
+                    // Add text if present
+                    if (item.text) {
+                        responseItem.text = item.text;
+                    }
+                    // If item has nested items (group), recursively build structure
+                    if (item.item && item.item.length > 0) {
+                        responseItem.item = buildResponseStructure(item.item);
+                    }
+                    // If item has initial values, add them as answers
+                    if (item.initial && item.initial.length > 0) {
+                        responseItem.answer = item.initial;
+                    }
+                    return responseItem;
+                });
+            };
+            const initialItems = buildResponseStructure(questionnaire.item);
+            // Initialize response structure with hierarchical structure
+            setResponse({
+                resourceType: "QuestionnaireResponse",
+                questionnaire: effectiveQuestionnaireId,
+                status: "in-progress",
+                authored: new Date().toISOString(),
+                item: initialItems,
+            });
+        }
+        else {
+            // Flat structure initialization
+            setResponse({
+                resourceType: "QuestionnaireResponse",
+                questionnaire: effectiveQuestionnaireId,
+                status: "in-progress",
+                authored: new Date().toISOString(),
+                item: [],
+            });
+        }
+    }, [questionnaire, effectiveQuestionnaireId, useNestedStructure]);
+    const updateAnswer = (linkId, answer) => {
+        setResponse((prev) => {
+            const newResponse = { ...prev };
+            if (useNestedStructure) {
+                // Recursively find and update the item in the nested structure
+                const updateNestedItem = (items = []) => {
+                    return items.map((item) => {
+                        // If this is the item we're looking for, update it
+                        if (item.linkId === linkId) {
+                            return {
+                                linkId: item.linkId,
+                                ...(item.definition && { definition: item.definition }),
+                                ...(item.text && { text: item.text }),
+                                answer: [answer],
+                                ...(item.item && { item: item.item }),
+                            };
+                        }
+                        // If this item has nested items, search within them
+                        if (item.item && item.item.length > 0) {
+                            return {
+                                ...item,
+                                item: updateNestedItem(item.item),
+                            };
+                        }
+                        return item;
+                    });
+                };
+                newResponse.item = updateNestedItem(newResponse.item);
+            }
+            else {
+                // Flat structure: find or create the item
+                const findOrCreateItem = (items = []) => {
+                    const existingIndex = items.findIndex((item) => item.linkId === linkId);
+                    if (existingIndex >= 0) {
+                        // Update existing item
+                        const updated = [...items];
+                        const existingItem = updated[existingIndex];
+                        updated[existingIndex] = {
+                            linkId: existingItem.linkId,
+                            ...(existingItem.definition && {
+                                definition: existingItem.definition,
+                            }),
+                            ...(existingItem.text && { text: existingItem.text }),
+                            answer: [answer],
+                            ...(existingItem.item && { item: existingItem.item }),
+                        };
+                        return updated;
+                    }
+                    else {
+                        // Create new item
+                        return [
+                            ...items,
+                            {
+                                linkId,
+                                answer: [answer],
+                            },
+                        ];
+                    }
+                };
+                newResponse.item = findOrCreateItem(newResponse.item);
+            }
+            return newResponse;
+        });
+        // Clear validation error for this question when answered
+        setValidationErrors((prev) => {
+            const newErrors = new Set(prev);
+            newErrors.delete(linkId);
+            return newErrors;
+        });
+    };
+    const updateMultipleAnswers = (linkId, answers) => {
+        setResponse((prev) => {
+            const newResponse = { ...prev };
+            if (useNestedStructure) {
+                // Recursively find and update the item in the nested structure
+                const updateNestedItem = (items = []) => {
+                    return items.map((item) => {
+                        // If this is the item we're looking for, update it
+                        if (item.linkId === linkId) {
+                            return {
+                                linkId: item.linkId,
+                                ...(item.definition && { definition: item.definition }),
+                                ...(item.text && { text: item.text }),
+                                answer: answers,
+                                ...(item.item && { item: item.item }),
+                            };
+                        }
+                        // If this item has nested items, search within them
+                        if (item.item && item.item.length > 0) {
+                            return {
+                                ...item,
+                                item: updateNestedItem(item.item),
+                            };
+                        }
+                        return item;
+                    });
+                };
+                newResponse.item = updateNestedItem(newResponse.item);
+            }
+            else {
+                // Flat structure
+                const findOrCreateItem = (items = []) => {
+                    const existingIndex = items.findIndex((item) => item.linkId === linkId);
+                    if (existingIndex >= 0) {
+                        const updated = [...items];
+                        const existingItem = updated[existingIndex];
+                        updated[existingIndex] = {
+                            linkId: existingItem.linkId,
+                            ...(existingItem.definition && {
+                                definition: existingItem.definition,
+                            }),
+                            ...(existingItem.text && { text: existingItem.text }),
+                            answer: answers,
+                            ...(existingItem.item && { item: existingItem.item }),
+                        };
+                        return updated;
+                    }
+                    else {
+                        return [
+                            ...items,
+                            {
+                                linkId,
+                                answer: answers,
+                            },
+                        ];
+                    }
+                };
+                newResponse.item = findOrCreateItem(newResponse.item);
+            }
+            return newResponse;
+        });
+        // Clear validation error for this question when answered
+        setValidationErrors((prev) => {
+            const newErrors = new Set(prev);
+            newErrors.delete(linkId);
+            return newErrors;
+        });
+    };
+    const getAnswer = (linkId) => {
+        // Recursively search for the item in nested structure or flat structure
+        const findItem = (items) => {
+            if (!items)
+                return undefined;
+            for (const item of items) {
+                if (item.linkId === linkId) {
+                    return item;
+                }
+                if (item.item && item.item.length > 0) {
+                    const found = findItem(item.item);
+                    if (found)
+                        return found;
+                }
+            }
+            return undefined;
+        };
+        const item = findItem(response.item);
+        return item?.answer?.[0];
+    };
+    const getAnswers = (linkId) => {
+        // Recursively search for the item in nested structure or flat structure
+        const findItem = (items) => {
+            if (!items)
+                return undefined;
+            for (const item of items) {
+                if (item.linkId === linkId) {
+                    return item;
+                }
+                if (item.item && item.item.length > 0) {
+                    const found = findItem(item.item);
+                    if (found)
+                        return found;
+                }
+            }
+            return undefined;
+        };
+        const item = findItem(response.item);
+        return item?.answer || [];
+    };
+    const getRequiredQuestions = (pageItems) => {
+        // Recursively flatten nested groups so required questions inside them
+        // are included in page validation.
+        const allQuestionsOnPage = getAllQuestionsFromPage({
+            linkId: "__page__",
+            type: "group",
+            item: pageItems,
+        });
+        return allQuestionsOnPage.filter((item) => item.required === true);
+    };
+    const isNonEmptyString = (value) => typeof value === "string" && value.trim().length > 0;
+    const hasMeaningfulAnswer = (answer) => {
+        if (!answer)
+            return false;
+        // Primitive numeric/boolean values are meaningful even when 0/false.
+        if (answer.valueBoolean !== undefined)
+            return true;
+        if (answer.valueInteger !== undefined)
+            return true;
+        if (answer.valueDecimal !== undefined)
+            return true;
+        // String-like answers must be non-empty (trimmed) to be meaningful.
+        if (isNonEmptyString(answer.valueString))
+            return true;
+        if (isNonEmptyString(answer.valueDate))
+            return true;
+        if (isNonEmptyString(answer.valueDateTime))
+            return true;
+        if (isNonEmptyString(answer.valueTime))
+            return true;
+        if (isNonEmptyString(answer.valueUri))
+            return true;
+        // Coding answers are meaningful when they contain at least one identifier.
+        if (answer.valueCoding &&
+            (isNonEmptyString(answer.valueCoding.code) ||
+                isNonEmptyString(answer.valueCoding.display) ||
+                isNonEmptyString(answer.valueCoding.system))) {
+            return true;
+        }
+        // Quantity answers are meaningful when a value is provided.
+        if (answer.valueQuantity?.value !== undefined)
+            return true;
+        return false;
+    };
+    const isPageValid = (pageItems) => {
+        const requiredQuestions = getRequiredQuestions(pageItems);
+        return requiredQuestions.every((question) => {
+            // For multi-select questions (repeats = true), check if there's at least one answer
+            if (question.repeats) {
+                const answers = getAnswers(question.linkId);
+                return answers.some((a) => hasMeaningfulAnswer(a));
+            }
+            // For single-answer questions
+            const answer = getAnswer(question.linkId);
+            return hasMeaningfulAnswer(answer);
+        });
+    };
+    const getUnansweredRequiredQuestions = (pageItems) => {
+        const requiredQuestions = getRequiredQuestions(pageItems);
+        return requiredQuestions.filter((question) => {
+            // For multi-select questions (repeats = true), check if there's at least one answer
+            if (question.repeats) {
+                const answers = getAnswers(question.linkId);
+                return !answers.some((a) => hasMeaningfulAnswer(a));
+            }
+            // For single-answer questions
+            const answer = getAnswer(question.linkId);
+            return !hasMeaningfulAnswer(answer);
+        });
+    };
+    const markValidationErrors = (pageItems) => {
+        const unansweredRequired = getUnansweredRequiredQuestions(pageItems);
+        const errorLinkIds = unansweredRequired.map((q) => q.linkId);
+        setValidationErrors(new Set(errorLinkIds));
+    };
+    const clearValidationErrors = () => {
+        setValidationErrors(new Set());
+    };
+    const hasValidationError = (linkId) => {
+        return validationErrors.has(linkId);
+    };
+    return (_jsx(QuestionnaireContext.Provider, { value: {
+            questionnaire,
+            response,
+            updateAnswer,
+            updateMultipleAnswers,
+            getAnswer,
+            getAnswers,
+            isPageValid,
+            getRequiredQuestions,
+            getUnansweredRequiredQuestions,
+            markValidationErrors,
+            clearValidationErrors,
+            hasValidationError,
+            debugMode,
+            toggleDebugMode,
+        }, children: children }));
+};

package/dist/esm/index.d.ts

@@ -0,0 +1,7 @@
+export { QuestionRenderer } from "./components/question-renderer.js";
+export type { QuestionRendererProps } from "./components/question-renderer.js";
+export { QuestionnaireProvider, useQuestionnaire, type QuestionnaireContextType, type QuestionnaireProviderProps, } from "./contexts/questionnaire-context.js";
+export type { Coding, Extension, Questionnaire, QuestionnaireItem, QuestionnaireItemAnswerOption, QuestionnaireResponse, QuestionnaireResponseAnswer, QuestionnaireResponseItem, } from "./types/fhir.js";
+export type { RadioInputProps, CheckboxInputProps, } from "./types/index.js";
+export { calculateProgress, getAllQuestionsFromPage, getExclusiveOptionCode, getVisiblePages, hasAnswerValue, isQuestionHidden, } from "./lib/questionnaire-utils.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,gBAAgB,EAAE,MAAM,mCAAmC,CAAC;AACrE,YAAY,EACV,qBAAqB,EACtB,MAAM,mCAAmC,CAAC;AAG3C,OAAO,EACL,qBAAqB,EACrB,gBAAgB,EAChB,KAAK,wBAAwB,EAC7B,KAAK,0BAA0B,GAChC,MAAM,qCAAqC,CAAC;AAG7C,YAAY,EACV,MAAM,EACN,SAAS,EACT,aAAa,EACb,iBAAiB,EACjB,6BAA6B,EAC7B,qBAAqB,EACrB,2BAA2B,EAC3B,yBAAyB,GAC1B,MAAM,iBAAiB,CAAC;AAEzB,YAAY,EACV,eAAe,EACf,kBAAkB,GACnB,MAAM,kBAAkB,CAAC;AAG1B,OAAO,EACL,iBAAiB,EACjB,uBAAuB,EACvB,sBAAsB,EACtB,eAAe,EACf,cAAc,EACd,gBAAgB,GACjB,MAAM,8BAA8B,CAAC"}

package/dist/esm/index.js

@@ -0,0 +1,6 @@
+// Components
+export { QuestionRenderer } from "./components/question-renderer.js";
+// Contexts
+export { QuestionnaireProvider, useQuestionnaire, } from "./contexts/questionnaire-context.js";
+// Utils
+export { calculateProgress, getAllQuestionsFromPage, getExclusiveOptionCode, getVisiblePages, hasAnswerValue, isQuestionHidden, } from "./lib/questionnaire-utils.js";

package/dist/esm/lib/questionnaire-utils.d.ts

@@ -0,0 +1,29 @@
+import type { Questionnaire, QuestionnaireItem } from "../types/fhir.js";
+/**
+ * Get visible pages from a questionnaire (excludes hidden groups)
+ */
+export declare const getVisiblePages: (questionnaire: Questionnaire) => QuestionnaireItem[];
+/**
+ * Calculate progress percentage
+ * @param currentPageIndex 0-based page index
+ * @param totalPages Total number of pages
+ * @returns Progress percentage (0-100)
+ */
+export declare const calculateProgress: (currentPageIndex: number, totalPages: number) => number;
+/**
+ * Get all questions from a page (flattens nested groups)
+ */
+export declare const getAllQuestionsFromPage: (pageItem: QuestionnaireItem) => QuestionnaireItem[];
+/**
+ * Check if a question has any answer value
+ */
+export declare const hasAnswerValue: (answer: any) => boolean;
+/**
+ * Check if a question item should be hidden based on extensions
+ */
+export declare const isQuestionHidden: (item: QuestionnaireItem) => boolean;
+/**
+ * Get the exclusive option code from a question item (if any)
+ */
+export declare const getExclusiveOptionCode: (item: QuestionnaireItem) => string | undefined;
+//# sourceMappingURL=questionnaire-utils.d.ts.map

package/dist/esm/lib/questionnaire-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"questionnaire-utils.d.ts","sourceRoot":"","sources":["../../../src/lib/questionnaire-utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AAEzE;;GAEG;AACH,eAAO,MAAM,eAAe,GAAI,eAAe,aAAa,KAAG,iBAAiB,EAc/E,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,iBAAiB,GAAI,kBAAkB,MAAM,EAAE,YAAY,MAAM,KAAG,MAGhF,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,uBAAuB,GAAI,UAAU,iBAAiB,KAAG,iBAAiB,EAsBtF,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,cAAc,GAAI,QAAQ,GAAG,KAAG,OAe5C,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,gBAAgB,GAAI,MAAM,iBAAiB,KAAG,OAM1D,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,sBAAsB,GAAI,MAAM,iBAAiB,KAAG,MAAM,GAAG,SAKzE,CAAC"}

package/dist/esm/lib/questionnaire-utils.js

@@ -0,0 +1,80 @@
+/**
+ * Get visible pages from a questionnaire (excludes hidden groups)
+ */
+export const getVisiblePages = (questionnaire) => {
+    if (!questionnaire.item)
+        return [];
+    return questionnaire.item.filter((item) => {
+        // Check if hidden
+        const isHidden = item.extension?.some((ext) => ext.url === "http://hl7.org/fhir/StructureDefinition/questionnaire-hidden" &&
+            ext.valueBoolean === true);
+        // Only include visible group items
+        return item.type === "group" && !isHidden;
+    });
+};
+/**
+ * Calculate progress percentage
+ * @param currentPageIndex 0-based page index
+ * @param totalPages Total number of pages
+ * @returns Progress percentage (0-100)
+ */
+export const calculateProgress = (currentPageIndex, totalPages) => {
+    if (totalPages === 0)
+        return 0;
+    return ((currentPageIndex + 1) / totalPages) * 100;
+};
+/**
+ * Get all questions from a page (flattens nested groups)
+ */
+export const getAllQuestionsFromPage = (pageItem) => {
+    const questions = [];
+    const collectQuestions = (items) => {
+        if (!items)
+            return;
+        for (const item of items) {
+            if (item.type === "group" && item.item) {
+                // Recursively collect from nested groups
+                collectQuestions(item.item);
+            }
+            else if (item.type !== "display") {
+                // Add non-display items (actual questions)
+                questions.push(item);
+            }
+        }
+    };
+    if (pageItem.item) {
+        collectQuestions(pageItem.item);
+    }
+    return questions;
+};
+/**
+ * Check if a question has any answer value
+ */
+export const hasAnswerValue = (answer) => {
+    if (!answer)
+        return false;
+    return (answer.valueBoolean !== undefined ||
+        answer.valueInteger !== undefined ||
+        answer.valueDecimal !== undefined ||
+        answer.valueString !== undefined ||
+        answer.valueCoding !== undefined ||
+        answer.valueDate !== undefined ||
+        answer.valueDateTime !== undefined ||
+        answer.valueTime !== undefined ||
+        answer.valueUri !== undefined ||
+        answer.valueQuantity !== undefined);
+};
+/**
+ * Check if a question item should be hidden based on extensions
+ */
+export const isQuestionHidden = (item) => {
+    return item.extension?.some((ext) => ext.url === "http://hl7.org/fhir/StructureDefinition/questionnaire-hidden" &&
+        ext.valueBoolean === true) ?? false;
+};
+/**
+ * Get the exclusive option code from a question item (if any)
+ */
+export const getExclusiveOptionCode = (item) => {
+    const exclusiveExt = item.extension?.find((ext) => ext.url === "http://codes.welshare.app/StructureDefinition/questionnaire-exclusive-option");
+    return exclusiveExt?.valueString;
+};

package/dist/esm/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}