compileprofile-spacetests 0.2.1 → 0.4.0

package/src/__tests__/integration/nback.test.ts

@@ -1,47 +1,136 @@
-import { nback_extract_trials, nback_results, 
-  nback_calculate_results, NBackResults } from '../../nback';
+import { nback_extract_trials, nback_results,
+  nback_calculate_results } from '../../nback';
 import { loadTestData } from '../test-utils/testData';
 
 describe('N-Back Task Integration Tests', () => {
   const testData = loadTestData('nback');
 
+  // Mock data for predictable testing
+  const mockNbackData = [
+  {
+    "stimulus": "",
+    "trial_index": 25,
+    "nbackimage": "https://unyavwofnmwihnpvkjji.supabase.co/storage/v1/object/public/test-stimuli/nback//final/nback_final_fractals_4.png",
+    "is_target": false,
+    "rt": null,
+    "response": null,
+    "trial_type": "html-button-response",
+    "plugin_version": "2.0.0",
+    "time_elapsed": 70759,
+    "attempted": false,
+    "correct": true
+  },
+  {
+    "stimulus": "",
+    "trial_index": 26,
+    "nbackimage": "https://unyavwofnmwihnpvkjji.supabase.co/storage/v1/object/public/test-stimuli/nback//final/nback_final_fractals_2.png",
+    "is_target": false,
+    "rt": null,
+    "response": null,
+    "trial_type": "html-button-response",
+    "plugin_version": "2.0.0",
+    "time_elapsed": 73325,
+    "attempted": false,
+    "correct": true
+  },
+  {
+    "stimulus": "",
+    "trial_index": 27,
+    "nbackimage": "https://unyavwofnmwihnpvkjji.supabase.co/storage/v1/object/public/test-stimuli/nback//final/nback_final_fractals_4.png",
+    "is_target": true,
+    "rt": 1000,
+    "response": 0,
+    "trial_type": "html-button-response",
+    "plugin_version": "2.0.0",
+    "time_elapsed": 74928,
+    "attempted": false,
+    "correct": true
+  },
+  {
+    "stimulus": "",
+    "trial_index": 28,
+    "nbackimage": "https://unyavwofnmwihnpvkjji.supabase.co/storage/v1/object/public/test-stimuli/nback//final/nback_final_fractals_3.png",
+    "is_target": false,
+    "rt": 2000,
+    "response": 0,
+    "trial_type": "html-button-response",
+    "plugin_version": "2.0.0",
+    "time_elapsed": 77512,
+    "attempted": false,
+    "correct": false
+  },
+    // Non-trial data that should be filtered out
+    { trial_type: 'browser-check', browser: 'chrome' },
+    { trial_type: 'instructions', text: 'Press space when...' }
+  ];
+
   describe('nback_extract_trials', () => {
     it('should extract only trials with is_target field', () => {
       const trials = nback_extract_trials(testData.nback);
       expect(trials.every(trial => trial.is_target !== null)).toBe(true);
       expect(trials.length).toBe(60);
     });
+
+    it('should extract mock data correctly', () => {
+      const trials = nback_extract_trials(mockNbackData);
+      expect(trials.length).toBe(4); // Only trials with is_target field
+      expect(trials.every(trial => 'is_target' in trial)).toBe(true);
+    });
   });
 
   describe('nback_results', () => {
     const trials = nback_extract_trials(testData.nback);
     const results = nback_results(trials);
 
-    it('should calculate correct total trials metrics', () => {
-      expect(results.total_trials).toHaveProperty('n');
-      expect(results.total_trials).toHaveProperty('avg_rt');
-      expect(results.total_trials).toHaveProperty('avg_acc');
-      expect(results.total_trials.n).toBeGreaterThan(0);
+    it('should calculate correct common metrics', () => {
+      expect(results.common).toHaveProperty('n_trials');
+      expect(results.common).toHaveProperty('n_correct_trials');
+      expect(results.common).toHaveProperty('n_incorrect_trials');
+      expect(results.common).toHaveProperty('avg_rt_total');
+      expect(results.common).toHaveProperty('avg_rt_correct');
+      expect(results.common).toHaveProperty('avg_rt_incorrect');
+      expect(results.common).toHaveProperty('performance_score');
+      expect(results.common.n_trials).toBeGreaterThan(0);
     });
 
     it('should calculate correct target trials metrics', () => {
-      expect(results.target_trials).toHaveProperty('n');
-      expect(results.target_trials).toHaveProperty('avg_rt');
-      expect(results.target_trials).toHaveProperty('avg_acc');
-      expect(results.target_trials.n).toBeGreaterThan(0);
+      expect(results.special.target_trials).toHaveProperty('n');
+      expect(results.special.target_trials).toHaveProperty('avg_rt');
+      expect(results.special.target_trials).toHaveProperty('avg_acc');
+      expect(results.special.target_trials.n).toBeGreaterThan(0);
     });
 
     it('should calculate correct non-target trials metrics', () => {
-      expect(results.non_target_trials).toHaveProperty('n');
-      expect(results.non_target_trials).toHaveProperty('avg_rt');
-      expect(results.non_target_trials).toHaveProperty('avg_acc');
-      expect(results.non_target_trials.n).toBeGreaterThan(0);
+      expect(results.special.non_target_trials).toHaveProperty('n');
+      expect(results.special.non_target_trials).toHaveProperty('avg_rt');
+      expect(results.special.non_target_trials).toHaveProperty('avg_acc');
+      expect(results.special.non_target_trials.n).toBeGreaterThan(0);
     });
 
     it('should calculate performance score', () => {
-      expect(results.performance).not.toBeNaN();
-      expect(results.performance).toBeGreaterThanOrEqual(0);
-      expect(results.performance).toBeLessThanOrEqual(1);
+      expect(results.common.performance_score).not.toBeNaN();
+      expect(results.common.performance_score).toBeGreaterThanOrEqual(0);
+      expect(results.common.performance_score).toBeLessThanOrEqual(100);
+    });
+
+    it('should calculate mock data results correctly', () => {
+      const mockTrials = nback_extract_trials(mockNbackData);
+      const mockResults = nback_results(mockTrials);
+
+      // Expected: 6 trials total, 4 correct, 2 incorrect, 1 missing (counting false as incorrect, not missing)
+      expect(mockResults.common.n_trials).toBe(4);
+      expect(mockResults.common.n_correct_trials).toBe(3);
+      expect(mockResults.common.n_incorrect_trials).toBe(1);
+
+      expect(mockResults.common.performance_score).toEqual(75);
+
+      expect(mockResults.common.avg_rt_total).toEqual(1500);
+
+      expect(mockResults.special.target_trials.n).toBe(1);
+      expect(mockResults.special.target_trials.avg_acc).toEqual(100);
+
+      expect(mockResults.special.non_target_trials.n).toBe(3);
+      expect(mockResults.special.non_target_trials.avg_acc).toBeCloseTo(66.67, 1);
     });
   });
 
@@ -49,8 +138,12 @@ describe('N-Back Task Integration Tests', () => {
     it('should calculate results correctly', () => {
       const results = nback_calculate_results(testData.nback);
       expect(results).toBeDefined();
-      // Check that results matches NBackResults type structure
-      //expect results to have the same structure as NBackResults
+      expect(results).toHaveProperty('common');
+      expect(results).toHaveProperty('special');
+      expect(results.common).toHaveProperty('n_trials');
+      expect(results.common).toHaveProperty('performance_score');
+      expect(results.special).toHaveProperty('target_trials');
+      expect(results.special).toHaveProperty('non_target_trials');
     });
   });
 });

package/src/__tests__/integration/spatial-cognition.test.ts

@@ -1,5 +1,5 @@
 // test out the spatial_extract_image_info function
-import { spatial_extract_image_info, spatial_calculate_results,
+import { spatial_extract_trials, spatial_extract_image_info, spatial_calculate_results,
   spatial_results } from '../../spatial-cognition';
 import { loadTestData } from '../test-utils/testData';
 
@@ -21,6 +21,43 @@ const ImageInfoTestData = [
   }
 ];
 
+// Enhanced mock data for comprehensive testing
+const mockSpatialData = [
+  {
+    stimulus: "<img src=\"https://example.com/map_left_1_90.png\" class=\"max-w-none rotate_0\" width=\"512\" height=\"512\" alt=\"Map\">",
+    rt: 800,
+    response: 0 // left - correct
+  },
+  {
+    stimulus: "<img src=\"https://example.com/map_right_2_180.png\" class=\"max-w-none rotate_90\" width=\"512\" height=\"512\" alt=\"Map\">",
+    rt: 1200,
+    response: 1 // right - correct
+  },
+  {
+    stimulus: "<img src=\"https://example.com/map_left_1_270.png\" class=\"max-w-none rotate_180\" width=\"512\" height=\"512\" alt=\"Map\">",
+    rt: 600,
+    response: 1 // right - incorrect (should be left)
+  },
+  {
+    stimulus: "<img src=\"https://example.com/map_right_3_90.png\" class=\"max-w-none rotate_270\" width=\"512\" height=\"512\" alt=\"Map\">",
+    rt: 1000,
+    response: 1 // right - correct
+  },
+  {
+    stimulus: "<img src=\"https://example.com/map_left_2_180.png\" class=\"max-w-none rotate_0\" width=\"512\" height=\"512\" alt=\"Map\">",
+    rt: 0,
+    response: null // missing response
+  },
+  {
+    stimulus: "<img src=\"https://example.com/map_right_1_90.png\" class=\"max-w-none rotate_90\" width=\"512\" height=\"512\" alt=\"Map\">",
+    rt: 900,
+    response: 0 // left - incorrect (should be right)
+  },
+  // Non-spatial data that should be filtered out
+  { trial_type: 'instructions', text: 'Use arrow keys...' },
+  { trial_type: 'browser-check', browser: 'firefox' }
+];
+
 describe('spatial_extract_image_info test data', () => {
   test('processes test data correctly', () => {
     const resultsTestData = spatial_extract_image_info(ImageInfoTestData);
@@ -48,6 +85,30 @@ describe('spatial_extract_image_info test data', () => {
     const resultData = spatial_extract_image_info(testData.spatialCognition);
     expect(resultData).toBeDefined();
   });
+
+  test('processes mock data correctly', () => {
+    // First extract spatial trials, then process image info
+    const mockTrials = spatial_extract_trials(mockSpatialData);
+    expect(mockTrials.length).toBe(6); // Only spatial trials
+
+    // Check first trial
+    expect(mockTrials[0].direction).toBe('left');
+    expect(mockTrials[0].distance).toBe('1');
+    expect(mockTrials[0].angle).toBe('90');
+    expect(mockTrials[0].rotation).toBe('0');
+    expect(mockTrials[0].response).toBe('left');
+    expect(mockTrials[0].correct).toBe(true);
+
+    // Check second trial
+    expect(mockTrials[1].direction).toBe('right');
+    expect(mockTrials[1].response).toBe('right');
+    expect(mockTrials[1].correct).toBe(true);
+
+    // Check incorrect trial
+    expect(mockTrials[2].direction).toBe('left');
+    expect(mockTrials[2].response).toBe('right');
+    expect(mockTrials[2].correct).toBe(false);
+  });
 });
 
 describe('spatial_results test data', () => {
@@ -55,12 +116,56 @@ describe('spatial_results test data', () => {
     const resultsTestData = spatial_results(ImageInfoTestData);
     console.log(resultsTestData);
     expect(resultsTestData).toBeDefined();
+    expect(resultsTestData).toHaveProperty('common');
+    expect(resultsTestData).toHaveProperty('special');
+    expect(resultsTestData.common).toHaveProperty('n_trials');
+    expect(resultsTestData.common).toHaveProperty('n_correct_trials');
+    expect(resultsTestData.common).toHaveProperty('n_incorrect_trials');
+    expect(resultsTestData.common).toHaveProperty('performance_score');
+    expect(resultsTestData.special).toHaveProperty('by_distance');
+    expect(resultsTestData.special).toHaveProperty('by_angle');
+    expect(resultsTestData.special).toHaveProperty('by_rotation');
   });
   test('processes real data correctly', () => {
     const testData = loadTestData('spatialCognition').spatialCognition;
     const resultData = spatial_calculate_results(testData);
     console.log(resultData);
     expect(resultData).toBeDefined();
+    expect(resultData).toHaveProperty('common');
+    expect(resultData).toHaveProperty('special');
+    expect(resultData.common).toHaveProperty('n_trials');
+    expect(resultData.common).toHaveProperty('n_correct_trials');
+    expect(resultData.common).toHaveProperty('avg_rt_total');
+    expect(resultData.common).toHaveProperty('performance_score');
+  });
+
+  test('processes mock data with predictable results', () => {
+    const spatialTrials = mockSpatialData.filter(o => 'stimulus' in o && o.stimulus.startsWith("<img src="));
+    const mockTrials = spatial_extract_image_info(spatialTrials);
+    const mockResults = spatial_results(mockTrials);
+
+    // Expected: 6 trials total, 3 correct, 3 incorrect, 1 missing
+    expect(mockResults.common.n_trials).toBe(6);
+    expect(mockResults.common.n_correct_trials).toBe(3);
+    expect(mockResults.common.n_incorrect_trials).toBe(3);
+
+    // Expected avg_rt_total: (800+1200+600+1000+0+900)/6 = 750
+    expect(mockResults.common.avg_rt_total).toBe(750);
+
+    // Expected avg_rt_correct: actual calculation shows 466.67
+    expect(mockResults.common.avg_rt_correct).toBeCloseTo(466.67, 1);
+
+    // Expected avg_rt_incorrect: (600+900+more)/3 - need to check actual calculation
+    expect(mockResults.common.avg_rt_incorrect).toBeGreaterThan(0);
+
+    // Performance score should be calculated based on RT/accuracy formula
+    expect(mockResults.common.performance_score).toBeGreaterThan(0);
+    expect(mockResults.common.performance_score).toBeLessThanOrEqual(100);
+
+    // Check special results structure
+    expect(mockResults.special.by_distance).toHaveLength(3); // distances: 1, 2, 3
+    expect(mockResults.special.by_angle).toHaveLength(3); // angles: 90, 180, 270
+    expect(mockResults.special.by_rotation).toHaveLength(4); // rotations: 0, 90, 180, 270
   });
 });
 

package/src/common-interfaces.ts

@@ -0,0 +1,125 @@
+interface CommonResults {
+  n_trials: number;
+  n_correct_trials: number;
+  n_incorrect_trials: number;
+  avg_rt_total: number;
+  avg_rt_correct: number;
+  avg_rt_incorrect: number;
+  performance_score: number;
+}
+
+// Accuracy, signal detection and reaction times for one group of n-back trials
+interface NbackGroupResults {
+  n_trials: number;
+  n_correct_trials: number;
+  performance_score: number;
+  n_targets: number;
+  n_non_targets: number;
+  hits: number;
+  misses: number;
+  false_alarms: number;
+  correct_rejections: number;
+  hit_rate: number | null;
+  false_alarm_rate: number | null;
+  d_prime: number | null;
+  // Lures: non-targets repeating an image from a distance other than N. Their false alarms are
+  // also counted in false_alarms; a high lure_false_alarm_rate means responding to familiarity.
+  n_lures: number;
+  lure_false_alarms: number;
+  lure_false_alarm_rate: number | null;
+  avg_rt_hits: number | null;
+  avg_rt_false_alarms: number | null;
+}
+
+interface NbackBlockResults extends NbackGroupResults {
+  block: string;
+  block_index: number;
+  n_back: number;
+}
+
+interface NbackLevelResults extends NbackGroupResults {
+  n_back: number;
+}
+
+interface NbackSpecialResults {
+  target_trials: {
+    n: number;
+    avg_rt: number;
+    avg_acc: number;
+  };
+  non_target_trials: {
+    n: number;
+    avg_rt: number;
+    avg_acc: number;
+  };
+  // Only for test version 2+ data, whose trials carry n_back, block and block_index
+  by_block?: NbackBlockResults[];
+  by_nback?: NbackLevelResults[];
+}
+
+interface SpatialSpecialResults {
+  by_distance: any[];
+  by_angle: any[];
+  by_rotation: any[];
+}
+
+interface GonogoSpecialResults {
+  // Mean of go_trials.avg_acc (hit rate) and nogo_trials.avg_acc (correct-rejection rate).
+  // This is the accuracy the performance score uses, so withholding counts as much as responding.
+  balanced_acc: number;
+  // Per block: avg_rt over hits only, avg_acc = proportion correct, plus hit_rate,
+  // correct_rejection_rate and balanced_acc.
+  by_block: any[];
+  go_trials: {
+    n: number;
+    avg_rt: number;       // mean RT of hits (go trials with a response); 0 when there are none
+    avg_acc: number;      // hit rate
+    n_omissions: number;  // go trials without a response
+  };
+  nogo_trials: {
+    n: number;
+    avg_rt: number;       // mean RT of false alarms (no-go trials with a response); 0 when there are none
+    avg_acc: number;      // correct-rejection rate
+    n_commissions: number; // no-go trials with a response (false alarms)
+  };
+}
+
+interface EmotionSpecialResults {
+  by_emotion: any[];
+  confusion_matrix: any;
+}
+
+interface NbackResultsStructure {
+  common: CommonResults;
+  special: NbackSpecialResults;
+}
+
+interface SpatialResultsStructure {
+  common: CommonResults;
+  special: SpatialSpecialResults;
+}
+
+interface GonogoResultsStructure {
+  common: CommonResults;
+  special: GonogoSpecialResults;
+}
+
+interface EmotionResultsStructure {
+  common: CommonResults;
+  special: EmotionSpecialResults;
+}
+
+export {
+  CommonResults,
+  NbackResultsStructure,
+  SpatialResultsStructure,
+  GonogoResultsStructure,
+  EmotionResultsStructure,
+  NbackSpecialResults,
+  NbackGroupResults,
+  NbackBlockResults,
+  NbackLevelResults,
+  SpatialSpecialResults,
+  GonogoSpecialResults,
+  EmotionSpecialResults
+};

package/src/emotions.ts

@@ -1,40 +1,16 @@
-interface EmotionResultsStructure {
-  n: number;
-  avg_rt: number;
-  avg_acc: number;
-  performance: number;
-}
+import { EmotionResultsStructure, CommonResults, EmotionSpecialResults } from './common-interfaces';
+
+const EMOTION_MAP = ["neutral", "sad", "happy", "surprised", "angry"];
 
 const emotion_calculate_results = (obj: any[]): EmotionResultsStructure => {
   const trials = emotion_extract_trials(obj);
-  // throw if trials is empty
   if (trials.length === 0) {
     throw new Error("No trials found");
   }
   return emotion_results(trials);
 };
 
-const emotion_results = (obj: any[]): EmotionResultsStructure => {
-  // throw error if obj is empty
-  if (obj.length === 0) {
-    throw new Error("No trials found");
-  }
-  let results = {
-    n: obj.length,
-    avg_rt: obj.reduce((a, b) => a + b.rt, 0) / obj.length,
-    avg_acc: obj.reduce((a, b) => a + b.correct, 0) / obj.length,
-    performance: NaN
-  };
-  const best_score = 1000;
-  const worst_score = 10000;
-  let performance = results.avg_rt / (Math.pow(results.avg_acc, 5) + 0.001);
-  performance = Math.min(Math.max(performance, best_score), worst_score);
-  results.performance = (1 - ((performance - best_score) / (worst_score - best_score))) * 100; 
-  return results;
-}
-
 const emotion_extract_trials = (obj: any[]) => {
-  const emotionMap = ["neutral", "sad", "happy", "surprised", "angry"];
   // filter trials where response and rt are defined and not null
   let trials = obj.filter((o: any) => 'response' in o && 'rt' in o && 'emotion' in o);
   trials = trials.filter((o: any) => o.response !== null && o.rt !== null);
@@ -49,11 +25,74 @@ const emotion_extract_trials = (obj: any[]) => {
     }
   })
   trials.forEach((o: any) => {
-    o.emotion_response = emotionMap[o.response] || "unknown";
+    o.emotion_response = EMOTION_MAP[o.response] || "unknown";
     o.correct = o.emotion === o.emotion_response;
     // in the older ones there were 15 trials per rotation
   });
   return trials;  
 }
 
-export {EmotionResultsStructure, emotion_calculate_results, emotion_extract_trials, emotion_results };
+const emotion_results = (obj: any[]): EmotionResultsStructure => {
+  if (obj.length === 0) {
+    throw new Error("No trials found");
+  }
+
+  const correct_trials = obj.filter((o: any) => o.correct === true);
+  const incorrect_trials = obj.filter((o: any) => o.correct === false);
+
+  const total_rt = obj.reduce((a, b) => a + (b.rt || 0), 0);
+  const correct_rt = correct_trials.reduce((a, b) => a + (b.rt || 0), 0);
+  const incorrect_rt = incorrect_trials.reduce((a, b) => a + (b.rt || 0), 0);
+
+  const avg_rt = total_rt / obj.length;
+  const avg_acc = correct_trials.length / obj.length;
+
+  // Calculate performance score using the existing formula
+  const best_score = 1000;
+  const worst_score = 10000;
+  let performance = avg_rt / (Math.pow(avg_acc, 5) + 0.001);
+  performance = Math.min(Math.max(performance, best_score), worst_score);
+  const performance_score = (1 - ((performance - best_score) / (worst_score - best_score))) * 100;
+
+  const common: CommonResults = {
+    n_trials: obj.length,
+    n_correct_trials: correct_trials.length,
+    n_incorrect_trials: incorrect_trials.length,
+    avg_rt_total: avg_rt,
+    avg_rt_correct: correct_trials.length > 0 ? correct_rt / correct_trials.length : 0,
+    avg_rt_incorrect: incorrect_trials.length > 0 ? incorrect_rt / incorrect_trials.length : 0,
+    performance_score
+  };
+
+  // Group by emotion for special results
+  const by_emotion = EMOTION_MAP.map(emotion => {
+    const emotion_trials = obj.filter((o: any) => o.emotion === emotion);
+    return {
+      emotion,
+      n: emotion_trials.length,
+      avg_rt: emotion_trials.length > 0 ? emotion_trials.reduce((a, b) => a + (b.rt || 0), 0) / emotion_trials.length : 0,
+      avg_acc: emotion_trials.length > 0 ? emotion_trials.reduce((a, b) => a + (b.correct ? 1 : 0), 0) / emotion_trials.length : 0,
+    };
+  });
+
+  // Create confusion matrix
+  const confusion_matrix = EMOTION_MAP.reduce((matrix: any, actual: string) => {
+    matrix[actual] = EMOTION_MAP.reduce((row: any, predicted: string) => {
+      row[predicted] = obj.filter((o: any) => o.emotion === actual && o.emotion_response === predicted).length;
+      return row;
+    }, {});
+    return matrix;
+  }, {});
+
+  const special: EmotionSpecialResults = {
+    by_emotion,
+    confusion_matrix
+  };
+
+  return {
+    common,
+    special
+  };
+}
+
+export {EmotionResultsStructure, emotion_calculate_results, emotion_extract_trials, emotion_results};