compileprofile-spacetests 0.1.0

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

@@ -0,0 +1,56 @@
+import { nback_extract_trials, nback_results, 
+  nback_calculate_results, NBackResults } from '../../nback';
+import { loadTestData } from '../test-utils/testData';
+
+describe('N-Back Task Integration Tests', () => {
+  const testData = loadTestData('nback');
+
+  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);
+    });
+  });
+
+  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 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);
+    });
+
+    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);
+    });
+
+    it('should calculate performance score', () => {
+      expect(results.performance).not.toBeNaN();
+      expect(results.performance).toBeGreaterThanOrEqual(0);
+      expect(results.performance).toBeLessThanOrEqual(1);
+    });
+  });
+
+  describe('nback_calculate_results', () => {
+    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
+    });
+  });
+});

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

@@ -0,0 +1,59 @@
+// test out the spatial_extract_image_info function
+import { spatial_extract_image_info, 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();
+  });
+});
+

package/src/__tests__/test-utils/testData.ts

@@ -0,0 +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: []
+  };
+} 

package/src/getters.ts

@@ -0,0 +1,21 @@
+function getBrowserInformation(data: any[]): any {
+  const browserInfo = data.find(row => row.trial_type === "browser-check");
+  if (!browserInfo) {
+    return null;
+  }
+  return {
+    os: browserInfo.os,
+    mobile: browserInfo.mobile,
+    fullscreen: browserInfo.fullscreen,
+    vsync_rate: browserInfo.vsync_rate,
+    webcam: browserInfo.webcam,
+    microphone: browserInfo.microphone,
+    browser: browserInfo.browser,
+    browser_version: browserInfo.browser_version,
+    webaudio: browserInfo.webaudio,
+    width: browserInfo.width,
+    height: browserInfo.height
+  };
+}
+
+export { getBrowserInformation };

package/src/gonogo.ts

@@ -0,0 +1,37 @@
+// gonogo_create_trial_table <- function(txt) {
+//   arr <- fromJSON(txt)
+//   df <- as.data.frame(fromJSON(arr[[1]]))
+//   GONOGO_IMAGE_PATH <- "https://unyavwofnmwihnpvkjji.supabase.co/storage/v1/object/public/test-stimuli/gonogo/"
+//   df <- filter(df, !is.na(image))
+//   df <- select(df, trial_index, time_elapsed, rt,
+//                response, block_number, image)
+//   df$image <- gsub(GONOGO_IMAGE_PATH, "", df$image)
+//   df$image <- gsub(".png", "", df$image)
+//   df <- df %>%
+//     mutate(
+//       should_go = case_when(
+//         block_number == 1 & grepl("astronaut_trans_1", image) ~ TRUE,
+//         block_number == 2 & grepl("alien_trans_1", image) ~ TRUE,
+//         block_number == 3 & grepl("rocket_trans_1", image) ~ TRUE,
+//         block_number == 4 & !grepl("rocket_trans_1", image) ~ TRUE,
+//         TRUE ~ FALSE),
+//       did_go = !is.na(response),
+//       correct = should_go == did_go
+//     )
+//   return(df)
+// }
+
+const gonogo_calculate_results = (data: any) => {
+
+}
+
+const gonogo_extract_trials = (data: any) => {
+
+// GONOGO_IMAGE_PATH <- "https://unyavwofnmwihnpvkjji.supabase.co/storage/v1/object/public/test-stimuli/gonogo/"
+
+}
+
+
+const gonogo_results = (data: any) => {
+
+}

package/src/index.ts

@@ -0,0 +1,12 @@
+import { NBackResults, nback_calculate_results } from './nback';
+import { spatial_calculate_results, SpatialResults } from './spatial-cognition';
+
+const NbackResults = (obj: any[]): NBackResults => {
+  return nback_calculate_results(obj);
+}
+
+const SpatialCognitionResults = (obj: any[]): SpatialResults => {
+  return spatial_calculate_results(obj);
+}
+
+export { NbackResults, SpatialCognitionResults };

package/src/nback.ts

@@ -0,0 +1,53 @@
+// from the passed json extract those objects that have field is_target
+const nback_calculate_results = (obj: any[]): NBackResults => {
+  const trials = nback_extract_trials(obj);
+  return nback_results(trials);
+}
+
+const nback_extract_trials = (obj: any[]): any[] => {
+  const trials = obj.filter((o: any) => 'is_target' in o);
+  return trials;
+}
+
+interface NbackTrialResults {
+  n: number;
+  avg_rt: number;
+  avg_acc: number;
+}
+
+interface NBackResults {
+  total_trials: NbackTrialResults;
+  target_trials: NbackTrialResults;
+  non_target_trials: NbackTrialResults;
+  performance: number;
+}
+
+const nback_results = (trials: any[]): NBackResults  => {
+  const target_trials = trials.filter((o: any) => o.is_target);
+  const non_target_trials = trials.filter((o: any) => !o.is_target);
+
+  let results = {
+    total_trials: {
+      n: trials.length,
+      avg_rt: trials.reduce((a, b) => a + b.rt, 0)/trials.length,
+      avg_acc: trials.reduce((a, b) => a + b.correct, 0)/trials.length,
+    },
+    target_trials: {
+      n: target_trials.length,
+      avg_rt: target_trials.reduce((a, b) => a + b.rt, 0)/target_trials.length,
+      avg_acc: target_trials.reduce((a, b) => a + b.correct, 0)/target_trials.length,
+    },
+    non_target_trials: {
+      n: non_target_trials.length,
+      avg_rt: non_target_trials.reduce((a, b) => a + b.rt, 0)/non_target_trials.length,
+      avg_acc: non_target_trials.reduce((a, b) => a + b.correct, 0)/non_target_trials.length,
+    },
+    performance: NaN
+  }
+  results.performance = results.total_trials.avg_acc;
+  console.log(results);
+  return results;
+}
+
+export { nback_extract_trials, nback_results, 
+  nback_calculate_results, NBackResults };

package/src/spatial-cognition.ts

@@ -0,0 +1,59 @@
+interface SpatialResults {
+  n: number;
+  avg_rt: number;
+  avg_acc: number;
+  performance: number;
+}
+
+const spatial_calculate_results = (obj: any[]): SpatialResults => {
+  const trials = spatial_extract_trials(obj);
+  return spatial_results(trials);
+}
+
+const spatial_extract_trials = (obj: any[]) => {
+  let trials = obj.filter((o: any) => 'stimulus' in o && 
+    o.stimulus.startsWith("<img src="));
+  trials = spatial_extract_image_info(trials);
+  return trials;
+}
+
+const spatial_results = (obj: any[]): SpatialResults => {
+  const 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;
+  // results.avg_acc to the power of 5
+  let performance = results.avg_rt / (Math.pow(results.avg_acc, 5) + 0.001);
+  if (performance < best_score) {
+    performance = best_score;
+  }
+  if (performance > worst_score) {
+    performance = worst_score;
+  }
+  // convert to 0-100 where 100 is the best (200)
+  results.performance = (1 - ((performance - best_score) / (worst_score - best_score))) * 100; 
+  return results;
+}
+
+const spatial_extract_image_info = (obj: any[]) => {
+  // from the following field, extract the final image name (map_left_1_90.png), and rotation from the class attribute (rotate_0)
+  //  "stimulus": "<img src=\"https://unyavwofnmwihnpvkjji.supabase.co/storage/v1/object/public/test-stimuli/spatialcognition/map_left_1_90.png\" class=\"max-w-none rotate_0\" width=\"512\" height=\"512\" alt=\"Mapa\">",
+  obj.forEach((o: any) => {
+    // the image name is map_left_1_90.png
+    o.image = o.stimulus.match(/map_(left|right)_(\d+)_(\d+)\.png/)?.[0];
+    o.direction = o.stimulus.match(/map_(left|right)_(\d+)_(\d+)\.png/)?.[1];
+    o.distance = o.stimulus.match(/map_(left|right)_(\d+)_(\d+)\.png/)?.[2];
+    o.angle = o.stimulus.match(/map_(left|right)_(\d+)_(\d+)\.png/)?.[3];
+    o.rotation = o.stimulus.match(/rotate_(\d+)/)?.[1];
+    o.response = o.response === 1 ? "right" : "left";
+    o.correct = o.response === o.direction;
+  });
+  return obj;
+}
+
+export { spatial_extract_image_info, spatial_extract_trials, 
+  spatial_results, spatial_calculate_results, SpatialResults };

package/tsconfig.cjs.json

@@ -0,0 +1,13 @@
+{
+  "compilerOptions": {
+    "module": "commonjs",
+    "declaration": true,
+    "outDir": "./dist/cjs",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true
+  },
+  "include": ["src"],
+  "exclude": ["node_modules", "**/__tests__/*"]
+} 

package/tsconfig.esm.json

@@ -0,0 +1,15 @@
+// tsconfig.esm.json - For ES modules
+{
+  "compilerOptions": {
+    "module": "esnext",
+    "declaration": true,
+    "outDir": "./dist/esm",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "moduleResolution": "node",
+    "forceConsistentCasingInFileNames": true
+  },
+  "include": ["src"],
+  "exclude": ["node_modules", "**/__tests__/*"]
+}