@welshare/questionnaire 0.1.1 → 0.2.0

package/dist/node_modules/@welshare/questionnaire/src/contexts/questionnaire-context.tsx

@@ -1,499 +0,0 @@
-import {
-  createContext,
-  useContext,
-  useEffect,
-  useState,
-  type ReactNode,
-} from "react";
-import type {
-  Questionnaire,
-  QuestionnaireItem,
-  QuestionnaireResponse,
-  QuestionnaireResponseAnswer,
-  QuestionnaireResponseItem,
-} from "../types/fhir.js";
-import { getAllQuestionsFromPage } from "../lib/questionnaire-utils.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;
-}
-
-const QuestionnaireContext = createContext<
-  QuestionnaireContextType | undefined
->(undefined);
-
-export const useQuestionnaire = () => {
-  const context = useContext(QuestionnaireContext);
-  if (!context) {
-    throw new Error(
-      "useQuestionnaire must be used within QuestionnaireProvider"
-    );
-  }
-  return context;
-};
-
-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 const QuestionnaireProvider = ({
-  children,
-  questionnaire,
-  questionnaireId,
-  useNestedStructure = true,
-}: QuestionnaireProviderProps) => {
-  const [response, setResponse] = useState<QuestionnaireResponse>({
-    resourceType: "QuestionnaireResponse",
-    status: "in-progress",
-    item: [],
-  });
-  const [validationErrors, setValidationErrors] = useState<Set<string>>(
-    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?: QuestionnaireItem[]
-      ): QuestionnaireResponseItem[] => {
-        if (!questionnaireItems) return [];
-
-        return questionnaireItems.map((item) => {
-          const responseItem: QuestionnaireResponseItem = {
-            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: string,
-    answer: QuestionnaireResponseAnswer
-  ) => {
-    setResponse((prev) => {
-      const newResponse = { ...prev };
-
-      if (useNestedStructure) {
-        // Recursively find and update the item in the nested structure
-        const updateNestedItem = (
-          items: QuestionnaireResponseItem[] = []
-        ): QuestionnaireResponseItem[] => {
-          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: QuestionnaireResponseItem[] = []
-        ): QuestionnaireResponseItem[] => {
-          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: string,
-    answers: QuestionnaireResponseAnswer[]
-  ) => {
-    setResponse((prev) => {
-      const newResponse = { ...prev };
-
-      if (useNestedStructure) {
-        // Recursively find and update the item in the nested structure
-        const updateNestedItem = (
-          items: QuestionnaireResponseItem[] = []
-        ): QuestionnaireResponseItem[] => {
-          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: QuestionnaireResponseItem[] = []
-        ): QuestionnaireResponseItem[] => {
-          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: string
-  ): QuestionnaireResponseAnswer | undefined => {
-    // Recursively search for the item in nested structure or flat structure
-    const findItem = (
-      items?: QuestionnaireResponseItem[]
-    ): QuestionnaireResponseItem | undefined => {
-      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: string): QuestionnaireResponseAnswer[] => {
-    // Recursively search for the item in nested structure or flat structure
-    const findItem = (
-      items?: QuestionnaireResponseItem[]
-    ): QuestionnaireResponseItem | undefined => {
-      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: QuestionnaireItem[]
-  ): QuestionnaireItem[] => {
-    // 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: unknown): value is string =>
-    typeof value === "string" && value.trim().length > 0;
-
-  const hasMeaningfulAnswer = (answer?: QuestionnaireResponseAnswer): boolean => {
-    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: QuestionnaireItem[]): boolean => {
-    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: QuestionnaireItem[]
-  ): QuestionnaireItem[] => {
-    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: QuestionnaireItem[]) => {
-    const unansweredRequired = getUnansweredRequiredQuestions(pageItems);
-    const errorLinkIds = unansweredRequired.map((q) => q.linkId);
-    setValidationErrors(new Set(errorLinkIds));
-  };
-
-  const clearValidationErrors = () => {
-    setValidationErrors(new Set());
-  };
-
-  const hasValidationError = (linkId: string): boolean => {
-    return validationErrors.has(linkId);
-  };
-
-  return (
-    <QuestionnaireContext.Provider
-      value={{
-        questionnaire,
-        response,
-        updateAnswer,
-        updateMultipleAnswers,
-        getAnswer,
-        getAnswers,
-        isPageValid,
-        getRequiredQuestions,
-        getUnansweredRequiredQuestions,
-        markValidationErrors,
-        clearValidationErrors,
-        hasValidationError,
-        debugMode,
-        toggleDebugMode,
-      }}
-    >
-      {children}
-    </QuestionnaireContext.Provider>
-  );
-};

package/dist/node_modules/@welshare/questionnaire/src/index.ts

@@ -1,41 +0,0 @@
-// Components
-export { QuestionRenderer } from "./components/question-renderer.js";
-export type {
-  QuestionRendererProps
-} from "./components/question-renderer.js";
-
-// Contexts
-export {
-  QuestionnaireProvider,
-  useQuestionnaire,
-  type QuestionnaireContextType,
-  type QuestionnaireProviderProps,
-} from "./contexts/questionnaire-context.js";
-
-// Types
-export type {
-  Coding,
-  Extension,
-  Questionnaire,
-  QuestionnaireItem,
-  QuestionnaireItemAnswerOption,
-  QuestionnaireResponse,
-  QuestionnaireResponseAnswer,
-  QuestionnaireResponseItem,
-} from "./types/fhir.js";
-
-export type {
-  RadioInputProps,
-  CheckboxInputProps,
-} from "./types/index.js";
-
-// Utils
-export {
-  calculateProgress,
-  findQuestionnaireItem,
-  getAllQuestionsFromPage,
-  getExclusiveOptionCode,
-  getVisiblePages,
-  hasAnswerValue,
-  isQuestionHidden,
-} from "./lib/questionnaire-utils.js";