@tinyweb_dev/oe-exam-sdk 0.2.5 → 0.2.7

package/dist/components/exams/take/utils/question-transformers.js

@@ -4,6 +4,7 @@
  * Maps backend question types to frontend renderer props.
  * Each transformer handles specific question type data structure.
  */
+import { countBlanks, normalizeAcceptedAnswers, parseFillBlankStem, } from '../../../../shared/lib/utils/fill-in-blank';
 /**
  * Group questions by part_id AND questionGroup.id
  * This ensures questions with different passages (different questionGroups)
@@ -154,55 +155,20 @@ export function transformFillInBlank(questions) {
     const content = firstQuestion?.content;
     const groupPayload = firstQuestion?.questionGroup?.payload;
     const transformed = [];
-    /** Take UI shows plain textBefore/textAfter — strip `**` so markers never leak. */
-    const stripStemBoldMarkers = (s) => s.replace(/\*\*/g, '');
     for (const q of questions) {
         const qContent = q.content;
-        const isExample = q.is_example || false;
         // Support both: content.question (new) and content.blanks[0].text (legacy)
         const text = qContent.question || qContent.blanks?.[0]?.text || '';
-        // Check for multiple placeholders: {0}, {1}, etc.
-        const placeholderMatches = [...text.matchAll(/\{(\d+)\}/g)];
-        if (placeholderMatches.length > 1) {
-            // Multi-placeholder: split into separate lines by newline or by placeholder
-            const lines = text.split('\n').filter((l) => l.trim());
-            for (const line of lines) {
-                const lineMatch = line.match(/\{(\d+)\}/);
-                if (!lineMatch)
-                    continue;
-                const blankIndex = parseInt(lineMatch[1], 10);
-                const parts = line.split(/\{\d+\}/);
-                const textBefore = stripStemBoldMarkers(parts[0]?.trim() || '');
-                const textAfter = stripStemBoldMarkers(parts[1]?.trim() || '');
-                transformed.push({
-                    id: `${q.id}-blank-${blankIndex}`,
-                    questionNumber: q.question_number,
-                    textBefore,
-                    textAfter,
-                    imageUrl: qContent.imageUrl,
-                    hints: qContent.hints,
-                    isExample,
-                    correctAnswer: isExample ? q.correct_answer?.answers?.[blankIndex] : undefined,
-                });
-            }
-        }
-        else {
-            // Single placeholder or no placeholder.
-            // Use [\s\S] so stems with newlines still match (`.` does not cross `\n`).
-            const match = text.match(/^([\s\S]*?)\{0\}([\s\S]*)$/);
-            const textBefore = stripStemBoldMarkers(match ? match[1].trim() : text);
-            const textAfter = stripStemBoldMarkers(match ? match[2].trim() : '');
-            transformed.push({
-                id: q.id,
-                questionNumber: q.question_number,
-                textBefore,
-                textAfter,
-                imageUrl: qContent.imageUrl,
-                hints: qContent.hints,
-                isExample,
-                correctAnswer: isExample ? q.correct_answer?.answers?.[0] : undefined,
-            });
-        }
+        const segments = parseFillBlankStem(text);
+        transformed.push({
+            id: q.id,
+            questionNumber: q.question_number,
+            segments,
+            acceptedAnswers: normalizeAcceptedAnswers(q.correct_answer?.answers, countBlanks(segments)),
+            imageUrl: qContent.imageUrl,
+            hints: qContent.hints,
+            isExample: q.is_example || false,
+        });
     }
     return {
         questions: transformed,
@@ -228,17 +194,17 @@ export function transformWriteCorrectVerbForm(questions) {
     const content = firstQuestion?.content;
     const transformed = questions.map((q) => {
         const qContent = q.content;
-        const sentence = qContent.sentence || '';
-        // Parse "John {0} his homework." -> textBefore: "John", textAfter: "his homework."
-        // [\s\S] allows instruction text with newlines before the blank.
-        const match = sentence.match(/^([\s\S]*?)\{0\}([\s\S]*)$/);
-        const textBefore = match ? match[1].trim() : sentence;
-        const textAfter = match ? match[2].trim() : '';
+        const segments = parseFillBlankStem(qContent.sentence || '');
+        // Stored as { correctAnswer: "doesn't like" }; older rows used { answers: { 'blank-1': … } }.
+        const correct = q.correct_answer;
+        const rawAccepted = Array.isArray(correct?.answers)
+            ? correct.answers
+            : (correct?.answers?.['blank-1'] ?? correct?.correctAnswer ?? correct?.answer);
         return {
             id: q.id,
             questionNumber: q.question_number,
-            textBefore,
-            textAfter,
+            segments,
+            acceptedAnswers: normalizeAcceptedAnswers(rawAccepted, countBlanks(segments)),
             verbHint: qContent.verbHint, // Pass verbHint per question
         };
     });
@@ -962,6 +928,63 @@ export function transformTrueFalseCorrectGroup(questions) {
             || 'Tick (✓) the true and cross (✗) the false sentences. Correct the false sentences.',
     };
 }
+function parseFillInBlankGroupAnswer(raw) {
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw)) {
+        return undefined;
+    }
+    const obj = raw;
+    if (!Array.isArray(obj.answers)) {
+        return undefined;
+    }
+    return {
+        answers: obj.answers.map((blank) => (Array.isArray(blank)
+            ? blank.map((alt) => String(alt ?? '').trim()).filter(Boolean)
+            : [String(blank ?? '').trim()].filter(Boolean))),
+        caseSensitive: obj.caseSensitive === true,
+    };
+}
+function blankCountFromMatches(matches) {
+    const indices = matches.map((match) => Number.parseInt(match[1], 10));
+    return Math.max(...indices, 0) + 1;
+}
+export function transformFillInBlankGroup(questions) {
+    const parent = questions[0];
+    const content = parent?.content;
+    const items = Array.isArray(content?.items) ? content.items : [];
+    const parentCorrect = Array.isArray(parent?.correct_answer?.answer)
+        ? parent.correct_answer.answer
+        : [];
+    const groupAudioUrl = content?.meta?.audioUrl?.trim() || '';
+    const transformed = items.map((item, index) => {
+        const parsed = parseFillInBlankGroupAnswer(item.correctAnswer ?? parentCorrect[index]);
+        const question = item.content?.question || '{0}';
+        const blankMatches = [...question.matchAll(/\{(\d+)\}/g)];
+        const blankCount = blankMatches.length > 0 ? blankCountFromMatches(blankMatches) : 1;
+        const isExample = item.isExample === true;
+        return {
+            id: `${parent.id}-item-${index}`,
+            questionNumber: item.questionNumber || index + 1,
+            question,
+            imageUrl: item.content?.imageUrl,
+            audioUrl: groupAudioUrl ? undefined : item.content?.audioUrl,
+            isExample,
+            blankCount,
+            exampleAnswers: isExample
+                ? Array.from({ length: blankCount }, (_, slot) => parsed?.answers?.[slot]?.[0] || '')
+                : undefined,
+        };
+    });
+    return {
+        questions: transformed,
+        instruction: content?.meta?.instruction || 'Complete the sentences.',
+        audioUrl: groupAudioUrl || undefined,
+        imageUrl: content?.meta?.imageUrl,
+        showHints: content?.meta?.showHints === true,
+        hints: Array.isArray(content?.meta?.hints)
+            ? content.meta.hints.map((hint) => String(hint ?? '').trim()).filter(Boolean)
+            : [],
+    };
+}
 export function transformWordOrdering(questions) {
     const transformed = questions.map((q) => {
         const content = q.content;
@@ -1326,3 +1349,36 @@ export function transformFindWordsInMatrix(questions) {
         explanation: question?.explanation,
     };
 }
+export function transformMatchingWithLinesGroup(questions) {
+    const parent = questions[0];
+    const content = (parent?.content || {});
+    const items = Array.isArray(content.items) ? content.items : [];
+    const parentCorrect = Array.isArray(parent?.correct_answer?.answer)
+        ? parent.correct_answer.answer
+        : [];
+    const rightItems = Array.isArray(content.rightItems)
+        ? content.rightItems.map((item, index) => ({
+            id: typeof item?.id === 'string' ? item.id : `r${index + 1}`,
+            text: typeof item?.text === 'string' ? item.text : '',
+        }))
+        : [];
+    return {
+        questions: items.map((item, index) => {
+            const isExample = item.isExample === true;
+            const fromItem = typeof item.correctAnswer?.answer === 'string' ? item.correctAnswer.answer : '';
+            const fromParent = typeof parentCorrect[index] === 'string' ? parentCorrect[index] : '';
+            return {
+                id: `${parent?.id || 'q'}-item-${index}`,
+                questionNumber: item.questionNumber || index + 1,
+                imageUrl: item.content?.imageUrl || '',
+                correctRightId: fromItem || fromParent,
+                isExample,
+                points: isExample ? 0 : (typeof item.points === 'number' ? item.points : 1),
+            };
+        }),
+        rightItems,
+        title: content.meta?.title || '',
+        instruction: content.meta?.instruction || 'Look and match.',
+        explanation: parent?.explanation,
+    };
+}

package/dist/components/questions/_shared/config/question-types.config.js

@@ -177,6 +177,11 @@ export const QUESTION_TYPE_CONFIG = {
         requiresContent: true,
         hasDedicatedComponent: true,
     },
+    FILL_IN_BLANK_GROUP: {
+        label: 'Điền chỗ trống (nhóm)',
+        requiresContent: true,
+        hasDedicatedComponent: true,
+    },
     CROSS_OUT_WORD_GROUP: {
         label: 'Cross out word (group)',
         requiresContent: true,
@@ -237,6 +242,11 @@ export const QUESTION_TYPE_CONFIG = {
         requiresContent: true,
         hasDedicatedComponent: true,
     },
+    MATCHING_WITH_LINES_GROUP: {
+        label: 'Nối bằng đường kẻ (nhóm)',
+        requiresContent: true,
+        hasDedicatedComponent: true,
+    },
     WRITE_SENTENCES: {
         label: 'Viết câu',
         requiresContent: true,
@@ -354,6 +364,7 @@ export const QUESTION_TYPES_WITH_DEDICATED_COMPONENTS = [
     'CHOOSE_THE_CORRECT_ANSWER_GROUP',
     'TRUE_FALSE_GROUP',
     'TRUE_FALSE_CORRECT_GROUP',
+    'FILL_IN_BLANK_GROUP',
     'CROSS_OUT_WORD_GROUP',
     'WRITE_A_SHORT_LETTER',
     'WRITE_CORRECT_VERB_FORM',
@@ -365,6 +376,7 @@ export const QUESTION_TYPES_WITH_DEDICATED_COMPONENTS = [
     'WORD_FILL_PARAGRAPH',
     'MATCH_BY_WRITING_ANSWER',
     'MATCH_WORD_TO_PICTURE',
+    'MATCHING_WITH_LINES_GROUP',
     'WRITE_SENTENCES',
     'LISTEN_AND_CHOOSE_FROM_ANSWER_GROUP',
     'LISTEN_AND_CHOOSE_OBJECTS_IN_SCENE',

package/dist/components/questions/_shared/types/fill-in-blank-group.type.d.ts

@@ -0,0 +1,50 @@
+import type { MutableRefObject } from 'react';
+export declare const FILL_IN_BLANK_ITEM_TYPE: "FILL_IN_BLANK";
+export declare const FILL_IN_BLANK_GROUP_DEFAULT_INSTRUCTION = "Complete the sentences.";
+export interface FillInBlankGroupItemAnswer {
+    answers: string[][];
+    caseSensitive?: boolean;
+}
+export interface FillInBlankGroupStudentItemAnswer {
+    answers: string[];
+}
+export interface FillInBlankGroupItemData {
+    question: string;
+    answers: string[][];
+    caseSensitive?: boolean;
+    imageUrl?: string;
+    audioUrl?: string;
+    showHints?: boolean;
+    hints?: string[];
+    isExample?: boolean;
+    points: number;
+    questionNumber: number;
+}
+export interface FillInBlankGroupData {
+    instruction: string;
+    audioUrl?: string;
+    imageUrl?: string;
+    showHints?: boolean;
+    hints?: string[];
+    items: FillInBlankGroupItemData[];
+    explanation?: string;
+    points?: number;
+}
+export interface FillInBlankGroupCreatorProps {
+    initialData?: FillInBlankGroupData;
+    onSave?: (data: FillInBlankGroupData) => void;
+    onCancel?: () => void;
+    onChange?: (data: FillInBlankGroupData) => void;
+    externalErrors?: string[];
+    onUnsavedChangesChange?: (hasUnsavedChanges: boolean) => void;
+    validationRef?: MutableRefObject<{
+        triggerValidation: () => Promise<boolean>;
+        getFormData?: () => FillInBlankGroupData;
+    } | null>;
+}
+export interface FillInBlankGroupClientProps {
+    questionData: FillInBlankGroupData;
+    isReviewMode?: boolean;
+    userAnswers?: FillInBlankGroupStudentItemAnswer[];
+    onAnswerChange?: (answers: FillInBlankGroupStudentItemAnswer[]) => void;
+}

package/dist/components/questions/_shared/types/fill-in-blank-group.type.js

@@ -0,0 +1,2 @@
+export const FILL_IN_BLANK_ITEM_TYPE = 'FILL_IN_BLANK';
+export const FILL_IN_BLANK_GROUP_DEFAULT_INSTRUCTION = 'Complete the sentences.';

package/dist/components/questions/_shared/types/fill-in-blank.type.d.ts

@@ -3,20 +3,32 @@ export type { ValidationRef };
 export interface BlankItem {
     id: string;
     text: string;
+    /** @deprecated Prefer correctAnswers — kept for legacy load */
     correctAnswer: string;
+    /** Equivalent correct answers for this blank */
+    correctAnswers?: string[];
 }
 export interface FillInBlankGroup {
     number: number;
     questionCount: number;
 }
+/**
+ * Main data interface - supports multiple blanks in a single question
+ * Question format: "He {0} 10 years old and she {1} 12."
+ * Answers format (canonical): [["is", "'s"], ["are"]]
+ *   - answers[i] = list of equivalent correct answers for placeholder {i}
+ * Legacy format still accepted when loading: ["is", "are"] → [["is"], ["are"]]
+ */
 export interface FillInBlankData {
     question: string;
-    answers: string[];
+    /** Per-blank list of equivalent correct answers */
+    answers: string[][];
     caseSensitive?: boolean;
     explanation?: string;
     points?: number;
     isExample?: boolean;
     imageUrl?: string;
+    audioUrl?: string;
     showHints?: boolean;
     hints?: string[];
     isGroup?: boolean;
@@ -41,9 +53,12 @@ export interface FillInBlankCreatorProps {
     groups?: FillInBlankGroup[];
     questionIndexInPart?: number;
     partId?: string;
+    /** Template questionConfig — controls which fields are shown (e.g. "audio") */
+    questionConfig?: string[];
 }
 export interface FillInBlankClientProps {
     questionData: FillInBlankData;
+    questionConfig?: string[];
     onSubmit?: (answers: string[]) => void;
     isReviewMode?: boolean;
     userAnswer?: string[];

package/dist/components/questions/_shared/types/index.d.ts

@@ -12,5 +12,7 @@ export * from './fill-in-blank.type';
 export * from './read-passage-and-answer-questions.type';
 export * from './word-fill-structured-form.type';
 export * from './true-false-correct-group.type';
+export * from './fill-in-blank-group.type';
 export * from './match-word-to-picture.type';
+export * from './matching-with-lines-group.type';
 export * from './spontaneous-qa-group.type';

package/dist/components/questions/_shared/types/index.js

@@ -12,5 +12,7 @@ export * from './fill-in-blank.type';
 export * from './read-passage-and-answer-questions.type';
 export * from './word-fill-structured-form.type';
 export * from './true-false-correct-group.type';
+export * from './fill-in-blank-group.type';
 export * from './match-word-to-picture.type';
+export * from './matching-with-lines-group.type';
 export * from './spontaneous-qa-group.type';

package/dist/components/questions/_shared/types/matching-with-lines-group.type.d.ts

@@ -0,0 +1,40 @@
+import type { MutableRefObject } from 'react';
+export declare const MATCHING_WITH_LINES_GROUP_DEFAULT_INSTRUCTION = "Look and match.";
+export interface MatchingWithLinesRightItem {
+    id: string;
+    text: string;
+}
+export interface MatchingWithLinesGroupItemData {
+    imageUrl: string;
+    correctAnswer: string;
+    isExample?: boolean;
+    points: number;
+    questionNumber: number;
+}
+export interface MatchingWithLinesGroupData {
+    title?: string;
+    instruction: string;
+    rightItems: MatchingWithLinesRightItem[];
+    items: MatchingWithLinesGroupItemData[];
+    explanation?: string;
+    points?: number;
+}
+export interface MatchingWithLinesGroupCreatorProps {
+    initialData?: MatchingWithLinesGroupData;
+    onSave?: (data: MatchingWithLinesGroupData) => void;
+    onCancel?: () => void;
+    onChange?: (data: MatchingWithLinesGroupData) => void;
+    externalErrors?: string[];
+    onUnsavedChangesChange?: (hasUnsavedChanges: boolean) => void;
+    validationRef?: MutableRefObject<{
+        triggerValidation: () => Promise<boolean>;
+        getFormData?: () => MatchingWithLinesGroupData;
+    } | null>;
+}
+export interface MatchingWithLinesGroupClientProps {
+    questionData: MatchingWithLinesGroupData;
+    isReviewMode?: boolean;
+    userAnswers?: string[];
+    onAnswerChange?: (index: number, rightId: string) => void;
+    onAnswersChange?: (next: string[]) => void;
+}

package/dist/components/questions/_shared/types/matching-with-lines-group.type.js

@@ -0,0 +1 @@
+export const MATCHING_WITH_LINES_GROUP_DEFAULT_INSTRUCTION = 'Look and match.';

package/dist/components/questions/components/QuestionSearchDropdown.js

@@ -23,11 +23,13 @@ const IMAGE_BASED_TYPES = [
     'LOOK_PICTURE_CHOOSE_CORRECT_ANSWER',
     'LOOK_PICTURE_FILL_WORD_HINT',
     'FILL_IN_BLANK',
+    'FILL_IN_BLANK_GROUP',
     'LABEL_THE_PICTURE',
     'READ_AND_COLOR_OBJECTS',
     'IMAGE_OBJECT_MATCHING',
     'FILL_IN_BLANK',
     'MATCH_WORD_TO_PICTURE',
+    'MATCHING_WITH_LINES_GROUP',
 ];
 // Passage-based question types
 const PASSAGE_BASED_TYPES = [
@@ -62,8 +64,10 @@ const getQuestionTypeName = (type) => {
         'IMAGE_OBJECT_MATCHING': 'Ghép hình ảnh - Đối tượng',
         'WRITE_CORRECT_VERB_FORM': 'Viết dạng động từ',
         'FILL_IN_BLANK': 'Điền vào chỗ trống',
+        'FILL_IN_BLANK_GROUP': 'Điền chỗ trống (nhóm)',
         'READ_PASSAGE_AND_ANSWER_QUESTIONS': 'Đọc hiểu',
         'MATCH_WORD_TO_PICTURE': 'Nối từ với tranh',
+        'MATCHING_WITH_LINES_GROUP': 'Nối bằng đường kẻ (nhóm)',
     };
     return type ? typeMap[type] || type.replace(/_/g, ' ').toLowerCase() : 'Chưa xác định';
 };

package/dist/components/questions/components/QuestionTypeSelector.js

@@ -27,7 +27,9 @@ export function QuestionTypeSelector({ value, onValueChange, disabled, }) {
         'WORD_ORDERING',
         'MATCH_BY_WRITING_ANSWER',
         'MATCH_WORD_TO_PICTURE',
+        'MATCHING_WITH_LINES_GROUP',
         'WRITE_SENTENCES',
+        'FILL_IN_BLANK_GROUP',
     ];
     return (_jsxs(Select, { value: value, onValueChange: onValueChange, disabled: disabled, children: [_jsx(SelectTrigger, { id: "questionType", className: "mt-1", children: _jsx(SelectValue, { placeholder: "Ch\u1ECDn lo\u1EA1i c\u00E2u h\u1ECFi" }) }), _jsx(SelectContent, { children: questionTypes.map((type) => (_jsx(SelectItem, { value: type, children: getQuestionTypeLabel(type) }, type))) })] }));
 }

package/dist/components/questions/creator/question-type-registry.js

@@ -14,6 +14,7 @@ import { chooseTheCorrectAnswerRegistration } from '../types/choose-the-correct-
 import { chooseTheCorrectAnswerGroupRegistration } from '../types/choose-the-correct-answer-group/register';
 import { trueFalseGroupRegistration } from '../types/true-false-group/register';
 import { trueFalseCorrectGroupRegistration } from '../types/true-false-correct-group/register';
+import { fillInBlankGroupRegistration } from '../types/fill-in-blank-group/register';
 import { crossOutWordGroupRegistration } from '../types/cross-out-word-group/register';
 import { writeAShortLetterRegistration } from '../types/write-a-short-letter/register';
 import { writeCorrectVerbFormRegistration } from '../types/write-correct-verb-form/register';
@@ -25,6 +26,7 @@ import { wordOrderingRegistration } from '../types/word-ordering/register';
 import { wordFillParagraphRegistration } from '../types/word-fill-paragraph/register';
 import { matchByWritingAnswerRegistration } from '../types/match-by-writing-answer/register';
 import { matchWordToPictureRegistration } from '../types/match-word-to-picture/register';
+import { matchingWithLinesGroupRegistration } from '../types/matching-with-lines-group/register';
 import { writeSentencesRegistration } from '../types/write-sentences/register';
 import { listenAndChooseFromAnswerGroupRegistration } from '../types/listen-and-choose-from-answer-group/register';
 import { listenAndChooseObjectsInSceneRegistration } from '../types/listen-and-choose-objects-in-scene/register';
@@ -53,6 +55,7 @@ export const questionTypeRegistry = {
     CHOOSE_THE_CORRECT_ANSWER_GROUP: chooseTheCorrectAnswerGroupRegistration,
     TRUE_FALSE_GROUP: trueFalseGroupRegistration,
     TRUE_FALSE_CORRECT_GROUP: trueFalseCorrectGroupRegistration,
+    FILL_IN_BLANK_GROUP: fillInBlankGroupRegistration,
     CROSS_OUT_WORD_GROUP: crossOutWordGroupRegistration,
     WORD_ORDER_AND_MATCH_GROUP: wordOrderAndMatchGroupRegistration,
     FILL_IN_BLANK: fillInBlankRegistration,
@@ -76,6 +79,7 @@ export const questionTypeRegistry = {
     WORD_FILL_PARAGRAPH: wordFillParagraphRegistration, // Will need to handle viewMode mapping either here or in wrapper
     MATCH_BY_WRITING_ANSWER: matchByWritingAnswerRegistration,
     MATCH_WORD_TO_PICTURE: matchWordToPictureRegistration,
+    MATCHING_WITH_LINES_GROUP: matchingWithLinesGroupRegistration,
     WRITE_SENTENCES: writeSentencesRegistration,
     LISTEN_AND_CHOOSE_FROM_ANSWER_GROUP: listenAndChooseFromAnswerGroupRegistration,
     LISTEN_AND_CHOOSE_OBJECTS_IN_SCENE: listenAndChooseObjectsInSceneRegistration,

package/dist/components/questions/types/fill-in-blank/FillInBlankClient.d.ts

@@ -1,2 +1,2 @@
 import { FillInBlankClientProps } from '../../_shared/types/fill-in-blank.type';
-export declare function FillInBlankClient({ questionData, onSubmit, isReviewMode, userAnswer, autoFillCorrectAnswers, explanation: explanationProp, }: FillInBlankClientProps): import("react").JSX.Element;
+export declare function FillInBlankClient({ questionData, questionConfig, onSubmit, isReviewMode, userAnswer, autoFillCorrectAnswers, explanation: explanationProp, }: FillInBlankClientProps): import("react").JSX.Element;