@pie-element/image-cloze-association 3.5.0 → 3.5.1-beta.587

package/src/utils-correctness.js

@@ -1,57 +1,87 @@
 const getAllCorrectAnswers = (answers, responses) =>
-  answers.map(answer => ({
+  answers.map((answer) => ({
     ...answer,
-    isCorrect: responses[answer.containerIndex].includes(answer.value)
+    isCorrect: (responses[answer.containerIndex].images || []).includes(answer.value),
   }));
 
-const getValidAnswer = (answer, response) => response[answer.containerIndex].filter(res => res === answer.value);
+const getValidAnswer = (answer, response) =>
+  (response[answer.containerIndex].images || []).filter((res) => res === answer.value);
 
 const getUniqueCorrectAnswers = (answers, validResponses) => {
   let finalAnswers = answers;
 
   answers.forEach((answer1) => {
-    const valuesToParse = answers.filter(answer2 =>
-      (answer2.value === answer1.value) && (answer2.containerIndex === answer1.containerIndex));
+    const valuesToParse = answers.filter(
+      (answer2) => answer2.value === answer1.value && answer2.containerIndex === answer1.containerIndex,
+    );
 
     if (valuesToParse.length > 1) {
       // point only to duplicates but first
       valuesToParse.shift();
       // mark duplicates as incorrect
       valuesToParse.forEach((value, index) => {
-        finalAnswers = finalAnswers.map(finalAnswer => {
+        finalAnswers = finalAnswers.map((finalAnswer) => {
           if (finalAnswer.id === value.id) {
             let valid = getValidAnswer(finalAnswer, validResponses);
 
             return {
               ...finalAnswer,
-              isCorrect: valid.length > index + 1
-            }
+              isCorrect: valid.length > index + 1,
+            };
           }
           return finalAnswer;
-        })
+        });
       });
     }
   });
   return finalAnswers;
 };
 
+export const getUnansweredAnswers = (answers, validation) => {
+  const { validResponse: { value } = {} } = validation;
+
+  const unansweredAnswers = (value || []).reduce((unanswered, response, index) => {
+    const isAnswered = !!answers.find((answer) => answer.containerIndex === index);
+
+    if (!isAnswered) {
+      return [
+        ...unanswered,
+        {
+          id: `unanswered-${index}`,
+          value: response.images[0] || '',
+          containerIndex: index,
+          isCorrect: false,
+          hidden: true,
+        },
+      ];
+    }
+
+    return unanswered;
+  }, []);
+
+  return unansweredAnswers;
+};
+
 export const getAnswersCorrectness = (answers, validation) => {
-  const { validResponse: { value }, altResponses } = validation;
+  const {
+    validResponse: { value },
+    altResponses,
+  } = validation;
 
   const allCorrect = getAllCorrectAnswers(answers, value);
   const uniqueAnswers = getUniqueCorrectAnswers(allCorrect, value);
-  const noOfCorrect = uniqueAnswers.filter(answer => answer.isCorrect).length;
+  const noOfCorrect = uniqueAnswers.filter((answer) => answer.isCorrect).length;
 
   // Look for alternate correct responses if there are incorrect responses.
-  if ((noOfCorrect < uniqueAnswers.length) && (altResponses && altResponses.length)) {
-    const altUniqueStack = altResponses.map(altResponse => {
+  if (noOfCorrect < uniqueAnswers.length && altResponses && altResponses.length) {
+    const altUniqueStack = altResponses.map((altResponse) => {
       const altValue = altResponse.value;
 
       const altAllCorrect = getAllCorrectAnswers(answers, altValue);
       return getUniqueCorrectAnswers(altAllCorrect, altValue);
     });
     // Return the one with most correct answers.
-    return altUniqueStack.sort((a, b) => b.filter(c => c.isCorrect).length - a.filter(c => c.isCorrect).length)[0];
+    return altUniqueStack.sort((a, b) => b.filter((c) => c.isCorrect).length - a.filter((c) => c.isCorrect).length)[0];
   }
   return uniqueAnswers;
 };

package/src/__tests__/__snapshots__/possible-response-test.jsx.snap

@@ -1,13 +0,0 @@
-// Jest Snapshot v1, https://goo.gl/fbAQLP
-
-exports[`Possible Response snapshots canDrag renders 1`] = `
-<ContextConsumer>
-  <Component />
-</ContextConsumer>
-`;
-
-exports[`Possible Response snapshots data renders 1`] = `
-<ContextConsumer>
-  <Component />
-</ContextConsumer>
-`;

package/src/__tests__/__snapshots__/root-test.jsx.snap

@@ -1,38 +0,0 @@
-// Jest Snapshot v1, https://goo.gl/fbAQLP
-
-exports[`Root snapshots model renders 1`] = `
-<DndProvider
-  backend={[Function]}
->
-  <ImageClozeAssociationComponent
-    classes={Object {}}
-    model={
-      Object {
-        "answers": Array [
-          Object {
-            "containerIndex": 0,
-            "id": 1,
-            "value": "1",
-          },
-          Object {
-            "containerIndex": 1,
-            "id": 2,
-            "value": "2",
-          },
-        ],
-        "canDrag": true,
-        "draggingElement": Object {},
-        "duplicateResponses": false,
-        "image": Object {},
-        "maxResponsePerZone": 5,
-        "onAnswerSelect": [Function],
-        "onDragAnswerBegin": [Function],
-        "onDragAnswerEnd": [Function],
-        "possibleResponses": Array [],
-        "responseContainers": Array [],
-      }
-    }
-    updateAnswer={[Function]}
-  />
-</DndProvider>
-`;

package/src/__tests__/utils-test.js

@@ -1,211 +0,0 @@
-import { getAnswersCorrectness } from '../utils-correctness';
-
-const rhomb = 'rhomb';
-const trapeze = 'trapeze';
-const hexagon = 'hexagon';
-
-const answer1 = {
-  containerIndex: 0
,
-  id: 1,
-  value: rhomb
-};
-const answer2 = {
-  containerIndex: 0
,
-  id: 2,
-  value: rhomb
-};
-const answer3 = {
-  containerIndex: 0
,
-  id: 3,
-  value: trapeze
-};
-
-const answer4 = {
-  containerIndex: 1
,
-  id: 4,
-  value: hexagon,
-};
-
-describe('utils', () => {
-  let validResponses;
-
-  beforeEach(() => {
-    validResponses = {
-      validResponse: {
-        value: [
-          [rhomb],
-          [rhomb, trapeze]
-        ]
-      }
-    }
-  });
-
-  describe('correctness', () => {
-    it('marks correct answers as correct', () => {
-      const result = getAnswersCorrectness(
-        [answer1, {
-          ...answer3,
-          containerIndex: 1
-        }],
-        validResponses
-      );
-      expect(result).toEqual([{
-        ...answer1,
-        isCorrect: true
-      },{
-        ...answer3,
-        isCorrect: true,
-        containerIndex: 1
-      }]);
-    });
-
-    it('marks incorrect answers as incorrect', () => {
-      const result = getAnswersCorrectness(
-        [answer1, answer3],
-        validResponses
-      );
-      expect(result).toEqual([{
-        ...answer1,
-        isCorrect: true
-      },{
-        ...answer3,
-        isCorrect: false
-      }]);
-    });
-
-    it('marks duplicates as incorrect', () => {
-      const result = getAnswersCorrectness(
-        [answer1, answer2],
-        validResponses
-      );
-      expect(result).toEqual([{
-        ...answer1,
-        isCorrect: true
-      },{
-        ...answer2,
-        isCorrect: false
-      }]);
-    });
-
-    it('marks duplicates and incorrect as incorrect', () => {
-      const result = getAnswersCorrectness(
-        [answer1, answer2, answer3],
-        validResponses
-      );
-      expect(result).toEqual([{
-        ...answer1,
-        isCorrect: true
-      },{
-        ...answer2,
-        isCorrect: false
-      },{
-        ...answer3,
-        isCorrect: false
-      }]);
-    });
-
-    describe('alternate correct answers', () => {
-      describe('handles one option', () => {
-        it('marks correct answers as correct', () => {
-          const result = getAnswersCorrectness(
-            [answer1, answer4],
-            {
-              ...validResponses,
-              altResponses: [{
-                value: [
-                  [rhomb],
-                  [hexagon]
-                ]
-              }]
-            }
-          );
-          expect(result).toEqual([{
-            ...answer1,
-            isCorrect: true
-          },{
-            ...answer4,
-            isCorrect: true
-          }]);
-        });
-
-        it('marks incorrect answers as incorrect', () => {
-          const result = getAnswersCorrectness(
-            [answer1, answer4],
-            {
-              ...validResponses,
-              altResponses: [{
-                value: [
-                  [hexagon],
-                  [rhomb]
-                ]
-              }]
-            }
-          );
-          expect(result).toEqual([{
-            ...answer1,
-            isCorrect: false
-          },{
-            ...answer4,
-            isCorrect: false
-          }]);
-        });
-      });
-
-      describe('handles multiple options', () => {
-        it('marks correct answers as correct', () => {
-          const result = getAnswersCorrectness(
-            [answer1, answer4],
-            {
-              ...validResponses,
-              altResponses: [{
-                value: [
-                  [hexagon],
-                  [rhomb]
-                ]
-              }, {
-                value: [
-                  [rhomb],
-                  [hexagon]
-                ]
-              }]
-            }
-          );
-          expect(result).toEqual([{
-            ...answer1,
-            isCorrect: true
-          },{
-            ...answer4,
-            isCorrect: true
-          }]);
-        });
-
-        it('marks incorrect answers as incorrect', () => {
-          const result = getAnswersCorrectness(
-            [answer1, answer4],
-            {
-              ...validResponses,
-              altResponses: [{
-                value: [
-                  [hexagon],
-                  [rhomb]
-                ]
-              }, {
-                value: [
-                  [hexagon],
-                  [hexagon]
-                ]
-              }]
-            }
-          );
-          expect(result).toEqual([{
-            ...answer1,
-            isCorrect: false
-          },{
-            ...answer4,
-            isCorrect: true
-          }]);
-        });
-      });
-    });
-  });
-});