compileprofile-spacetests 0.2.0 → 0.3.0

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

@@ -1,66 +1,171 @@
-// test out the spatial_extract_image_info function
-import { spatial_extract_image_info, spatial_calculate_results,
-  spatial_results } from '../../spatial-cognition';
-import { loadTestData } from '../test-utils/testData';
-
-const ImageInfoTestData = [
-  {
-    stimulus: "<img src=\"https://unyavwofnmwihnpvkjji.supabase.co/storage/v1/object/public/test-stimuli/spatialcognition/map_left_1_90.png\" class=\"max-w-none rotate_90\" width=\"512\" height=\"512\" alt=\"Mapa\">",
-    rt: 1411,
-    response: 0,
-    plugin_version: "2.0.0",
-    time_elapsed: 73045,
-    attempted: false
-  },
-  {
-    stimulus: "<img src=\"https://unyavwofnmwihnpvkjji.supabase.co/storage/v1/object/public/test-stimuli/spatialcognition/map_left_3_180.png\" class=\"max-w-none rotate_270\" width=\"512\" height=\"512\" alt=\"Mapa\">",
-    rt: 1411,
-    response: 1,
-    plugin_version: "2.0.0",
-    time_elapsed: 73045,
-  }
-];
-
-describe('spatial_extract_image_info test data', () => {
-  test('processes test data correctly', () => {
-    const resultsTestData = spatial_extract_image_info(ImageInfoTestData);
-    expect(resultsTestData.length).toBe(2);
-
-    expect(resultsTestData[0].image).toBe('map_left_1_90.png');
-    expect(resultsTestData[0].direction).toBe('left');
-    expect(resultsTestData[0].distance).toBe('1');
-    expect(resultsTestData[0].angle).toBe('90');
-    expect(resultsTestData[0].rotation).toBe('90');
-    expect(resultsTestData[0].response).toBe('left');
-    expect(resultsTestData[0].correct).toBe(true);
-
-    expect(resultsTestData[1].image).toBe('map_left_3_180.png');
-    expect(resultsTestData[1].direction).toBe('left');
-    expect(resultsTestData[1].distance).toBe('3');
-    expect(resultsTestData[1].angle).toBe('180');
-    expect(resultsTestData[1].rotation).toBe('270');
-    expect(resultsTestData[1].response).toBe('right');
-    expect(resultsTestData[1].correct).toBe(false);
-  });
-
-  test('processes real data correctly', () => {
-    const testData = loadTestData('spatial-cognition');
-    const resultData = spatial_extract_image_info(testData.spatialCognition);
-    expect(resultData).toBeDefined();
-  });
-});
-
-describe('spatial_results test data', () => {
-  test('processes test data correctly', () => {
-    const resultsTestData = spatial_results(ImageInfoTestData);
-    console.log(resultsTestData);
-    expect(resultsTestData).toBeDefined();
-  });
-  test('processes real data correctly', () => {
-    const testData = loadTestData('spatialCognition').spatialCognition;
-    const resultData = spatial_calculate_results(testData);
-    console.log(resultData);
-    expect(resultData).toBeDefined();
-  });
-});
-
+// test out the spatial_extract_image_info function
+import { spatial_extract_trials, spatial_extract_image_info, spatial_calculate_results,
+  spatial_results } from '../../spatial-cognition';
+import { loadTestData } from '../test-utils/testData';
+
+const ImageInfoTestData = [
+  {
+    stimulus: "<img src=\"https://unyavwofnmwihnpvkjji.supabase.co/storage/v1/object/public/test-stimuli/spatialcognition/map_left_1_90.png\" class=\"max-w-none rotate_90\" width=\"512\" height=\"512\" alt=\"Mapa\">",
+    rt: 1411,
+    response: 0,
+    plugin_version: "2.0.0",
+    time_elapsed: 73045,
+    attempted: false
+  },
+  {
+    stimulus: "<img src=\"https://unyavwofnmwihnpvkjji.supabase.co/storage/v1/object/public/test-stimuli/spatialcognition/map_left_3_180.png\" class=\"max-w-none rotate_270\" width=\"512\" height=\"512\" alt=\"Mapa\">",
+    rt: 1411,
+    response: 1,
+    plugin_version: "2.0.0",
+    time_elapsed: 73045,
+  }
+];
+
+// 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);
+    expect(resultsTestData.length).toBe(2);
+
+    expect(resultsTestData[0].image).toBe('map_left_1_90.png');
+    expect(resultsTestData[0].direction).toBe('left');
+    expect(resultsTestData[0].distance).toBe('1');
+    expect(resultsTestData[0].angle).toBe('90');
+    expect(resultsTestData[0].rotation).toBe('90');
+    expect(resultsTestData[0].response).toBe('left');
+    expect(resultsTestData[0].correct).toBe(true);
+
+    expect(resultsTestData[1].image).toBe('map_left_3_180.png');
+    expect(resultsTestData[1].direction).toBe('left');
+    expect(resultsTestData[1].distance).toBe('3');
+    expect(resultsTestData[1].angle).toBe('180');
+    expect(resultsTestData[1].rotation).toBe('270');
+    expect(resultsTestData[1].response).toBe('right');
+    expect(resultsTestData[1].correct).toBe(false);
+  });
+
+  test('processes real data correctly', () => {
+    const testData = loadTestData('spatial-cognition');
+    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', () => {
+  test('processes test data correctly', () => {
+    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/__tests__/test-utils/testData.ts

@@ -1,80 +1,80 @@
-import * as fs from 'fs';
-import * as path from 'path';
-
-// Define interfaces for our test data types
-export interface TestDataFiles {
-  spatialCognition: any[];
-  nback: any[];
-  participant: any[];
-  gonogo: any[];
-  emotions: any[];
-}
-
-// Function to load all test data
-export function loadTestData(type: string): TestDataFiles {
-  const dataDir = path.join(process.cwd(), 'example-data');
-  
-  if (type === 'spatialCognition') {
-    return {
-      spatialCognition: JSON.parse(fs.readFileSync(path.join(dataDir, 'spatial-cognition.json'), 'utf-8')),
-      nback: [],
-      participant: [],
-      gonogo: [],
-      emotions: []
-    };
-  }
-  if (type === 'nback') {
-    return {
-      spatialCognition: [],
-      nback: JSON.parse(fs.readFileSync(path.join(dataDir, 'nback.json'), 'utf-8')),
-      participant: [],
-      gonogo: [],
-      emotions: []
-    };
-  }
-  if (type === 'participant') {
-    return {
-      spatialCognition: [],
-      nback: [],
-      participant: JSON.parse(fs.readFileSync(path.join(dataDir, 'participant.json'), 'utf-8')),
-      gonogo: [],
-      emotions: []
-    };
-  }
-  if (type === 'gonogo') {
-      return {
-      spatialCognition: [],
-      nback: [],
-      participant: [],
-      gonogo: JSON.parse(fs.readFileSync(path.join(dataDir, 'gonogo.json'), 'utf-8')),
-      emotions: []
-    };
-  }
-  if (type === 'emotions') {
-    return {
-      spatialCognition: [],
-      nback: [],
-      participant: [],
-      gonogo: [],
-      emotions: JSON.parse(fs.readFileSync(path.join(dataDir, 'emotions.json'), 'utf-8'))
-    };
-  }
-  if (type === 'all') {
-    return {
-      spatialCognition: JSON.parse(fs.readFileSync(path.join(dataDir, 'spatial-cognition.json'), 'utf-8')),
-      nback: JSON.parse(fs.readFileSync(path.join(dataDir, 'nback.json'), 'utf-8')),
-      participant: JSON.parse(fs.readFileSync(path.join(dataDir, 'participant.json'), 'utf-8')),
-      gonogo: JSON.parse(fs.readFileSync(path.join(dataDir, 'gonogo.json'), 'utf-8')),
-      emotions: JSON.parse(fs.readFileSync(path.join(dataDir, 'emotions.json'), 'utf-8'))
-    };
-  }
-  
-  // Default return for unknown types
-  return {
-    spatialCognition: [],
-    nback: [],
-    participant: [],
-    gonogo: [],
-    emotions: []
-  };
+import * as fs from 'fs';
+import * as path from 'path';
+
+// Define interfaces for our test data types
+export interface TestDataFiles {
+  spatialCognition: any[];
+  nback: any[];
+  participant: any[];
+  gonogo: any[];
+  emotions: any[];
+}
+
+// Function to load all test data
+export function loadTestData(type: string): TestDataFiles {
+  const dataDir = path.join(process.cwd(), 'example-data');
+  
+  if (type === 'spatialCognition') {
+    return {
+      spatialCognition: JSON.parse(fs.readFileSync(path.join(dataDir, 'spatial-cognition.json'), 'utf-8')),
+      nback: [],
+      participant: [],
+      gonogo: [],
+      emotions: []
+    };
+  }
+  if (type === 'nback') {
+    return {
+      spatialCognition: [],
+      nback: JSON.parse(fs.readFileSync(path.join(dataDir, 'nback.json'), 'utf-8')),
+      participant: [],
+      gonogo: [],
+      emotions: []
+    };
+  }
+  if (type === 'participant') {
+    return {
+      spatialCognition: [],
+      nback: [],
+      participant: JSON.parse(fs.readFileSync(path.join(dataDir, 'participant.json'), 'utf-8')),
+      gonogo: [],
+      emotions: []
+    };
+  }
+  if (type === 'gonogo') {
+      return {
+      spatialCognition: [],
+      nback: [],
+      participant: [],
+      gonogo: JSON.parse(fs.readFileSync(path.join(dataDir, 'gonogo.json'), 'utf-8')),
+      emotions: []
+    };
+  }
+  if (type === 'emotions') {
+    return {
+      spatialCognition: [],
+      nback: [],
+      participant: [],
+      gonogo: [],
+      emotions: JSON.parse(fs.readFileSync(path.join(dataDir, 'emotions.json'), 'utf-8'))
+    };
+  }
+  if (type === 'all') {
+    return {
+      spatialCognition: JSON.parse(fs.readFileSync(path.join(dataDir, 'spatial-cognition.json'), 'utf-8')),
+      nback: JSON.parse(fs.readFileSync(path.join(dataDir, 'nback.json'), 'utf-8')),
+      participant: JSON.parse(fs.readFileSync(path.join(dataDir, 'participant.json'), 'utf-8')),
+      gonogo: JSON.parse(fs.readFileSync(path.join(dataDir, 'gonogo.json'), 'utf-8')),
+      emotions: JSON.parse(fs.readFileSync(path.join(dataDir, 'emotions.json'), 'utf-8'))
+    };
+  }
+  
+  // Default return for unknown types
+  return {
+    spatialCognition: [],
+    nback: [],
+    participant: [],
+    gonogo: [],
+    emotions: []
+  };
 } 

package/src/common-interfaces.ts

@@ -0,0 +1,79 @@
+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;
+}
+
+interface NbackSpecialResults {
+  target_trials: {
+    n: number;
+    avg_rt: number;
+    avg_acc: number;
+  };
+  non_target_trials: {
+    n: number;
+    avg_rt: number;
+    avg_acc: number;
+  };
+}
+
+interface SpatialSpecialResults {
+  by_distance: any[];
+  by_angle: any[];
+  by_rotation: any[];
+}
+
+interface GonogoSpecialResults {
+  by_block: any[];
+  go_trials: {
+    n: number;
+    avg_rt: number;
+    avg_acc: number;
+  };
+  nogo_trials: {
+    n: number;
+    avg_rt: number;
+    avg_acc: number;
+  };
+}
+
+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,
+  SpatialSpecialResults,
+  GonogoSpecialResults,
+  EmotionSpecialResults
+};

package/src/emotions.ts

@@ -1,59 +1,98 @@
-interface EmotionResults {
-  n: number;
-  avg_rt: number;
-  avg_acc: number;
-  performance: number;
-}
-
-const emotion_calculate_results = (obj: any[]): EmotionResults => {
-  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[]): EmotionResults => {
-  // 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);
-  trials.forEach((o: any) => {
-    const match = o.emotion.match(/\/([^/]+)_([0-9]+)\.png/);
-    if (match) {
-      o.stimulus = match[0];
-      o.emotion = match[1];
-      o.image_number = match[2];
-      //this is <emotion>_<number>.png
-      o.image = `${match[1]}_${match[2]}.png`;
-    }
-  })
-  trials.forEach((o: any) => {
-    o.emotion_response = emotionMap[o.response] || "unknown";
-    o.correct = o.emotion === o.emotion_response;
-    // in the older ones there were 15 trials per rotation
-  });
-  return trials;  
-}
-
-export { emotion_calculate_results, emotion_extract_trials, emotion_results };
+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);
+  if (trials.length === 0) {
+    throw new Error("No trials found");
+  }
+  return emotion_results(trials);
+};
+
+const emotion_extract_trials = (obj: any[]) => {
+  // 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);
+  trials.forEach((o: any) => {
+    const match = o.emotion.match(/\/([^/]+)_([0-9]+)\.png/);
+    if (match) {
+      o.stimulus = match[0];
+      o.emotion = match[1];
+      o.image_number = match[2];
+      //this is <emotion>_<number>.png
+      o.image = `${match[1]}_${match[2]}.png`;
+    }
+  })
+  trials.forEach((o: any) => {
+    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;  
+}
+
+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};