compileprofile-spacetests 0.2.1 → 0.4.0

package/dist/cjs/gonogo.js

@@ -1,71 +1,150 @@
 "use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.gonogo_results = exports.gonogo_extract_trials = exports.gonogo_calculate_results = void 0;
+var BEST_SCORE = 300;
+var WORST_SCORE = 5000;
 var gonogo_calculate_results = function (data) {
     var trials = gonogo_extract_trials(data);
     var results = gonogo_results(trials);
     return results;
 };
 exports.gonogo_calculate_results = gonogo_calculate_results;
+// Which stimulus is "go" in each block of the runner:
+// 1 astronaut, 2 alien, 3 rocket, 4 anything but the rocket (the UFOs).
+var should_go_for = function (block_number, stimulus) {
+    switch (block_number) {
+        case 1: return stimulus == "astronaut_trans_1.png";
+        case 2: return stimulus == "alien_trans_1.png";
+        case 3: return stimulus == "rocket_trans_1.png";
+        case 4: return stimulus != "rocket_trans_1.png";
+        default: return false;
+    }
+};
 var gonogo_extract_trials = function (obj) {
-    // GONOGO_IMAGE_PATH <- "https://unyavwofnmwihnpvkjji.supabase.co/storage/v1/object/public/test-stimuli/gonogo/"
-    var trials = obj.filter(function (o) { return 'image' in o && o.image !== undefined; });
-    trials.forEach(function (o) {
-        // image is in format <stimulus>_trans_<number>.png
-        // extract the stimulus and number
-        // "image": "https://unyavwofnmwihnpvkjji.supabase.co/storage/v1/object/public/test-stimuli/gonogo/aliens/astronaut_trans_1.png",
-        // i need to extract the iamge name from the url
-        var match = o.image.match(/([^/]+)_(\d+)\.png$/);
-        if (match) {
-            o.stimulus = match[0];
-            o.stimulustype = match[1];
-            o.image_number = match[2];
-        }
-        else {
+    var trials = [];
+    obj.filter(function (o) { return 'image' in o && o.image !== undefined && o.image !== null; }).forEach(function (o) {
+        // image is in format <stimulus>_trans_<number>.png, e.g.
+        // ".../test-stimuli/gonogo/aliens/astronaut_trans_1.png"
+        var match = String(o.image).match(/([^/]+)_(\d+)\.png$/);
+        if (!match) {
+            // Without a recognisable stimulus the trial cannot be scored, so leave it out
+            // instead of counting it as neither correct nor incorrect.
             console.warn('Image format did not match expected pattern:', o.image);
             return;
         }
-        o.should_go = false;
-        o.did_go = o.response !== null;
-        switch (o.block_number) {
-            case 1:
-                o.should_go = o.stimulus == "astronaut_trans_1.png";
-                break;
-            case 2:
-                o.should_go = o.stimulus == "alien_trans_1.png";
-                break;
-            case 3:
-                o.should_go = o.stimulus == "rocket_trans_1.png";
-                break;
-            case 4:
-                // should go in all cases where the goal is NOT the rocket
-                o.should_go = !(o.stimulus == "rocket_trans_1.png");
-                break;
-            default:
-                o.should_go = false;
-                break;
-        }
-        o.correct = o.should_go == o.did_go;
+        // Copy, so the caller's data is not modified.
+        var trial = __assign({}, o);
+        trial.stimulus = match[0];
+        trial.stimulustype = match[1];
+        trial.image_number = match[2];
+        // Prefer a go/no-go flag recorded by the runner; otherwise derive it from block and image.
+        trial.should_go = typeof o.should_go === 'boolean' ? o.should_go : should_go_for(o.block_number, trial.stimulus);
+        trial.did_go = o.response !== null && o.response !== undefined;
+        trial.correct = trial.should_go == trial.did_go;
+        trials.push(trial);
     });
     return trials;
 };
 exports.gonogo_extract_trials = gonogo_extract_trials;
+var has_rt = function (o) { return o.did_go === true && typeof o.rt === 'number' && !isNaN(o.rt); };
+// Mean of the values; 0 for an empty list, so callers always get a number.
+var mean = function (values) { return values.length > 0 ? values.reduce(function (a, b) { return a + b; }, 0) / values.length : 0; };
+// Mean RT over the trials that have a response; trials without one have no RT and are not averaged in as 0.
+var mean_rt = function (trials) { return mean(trials.filter(has_rt).map(function (o) { return o.rt; })); };
+var proportion = function (trials, pred) {
+    return trials.length > 0 ? trials.filter(pred).length / trials.length : 0;
+};
+// Hit rate and correct-rejection rate weighted equally. When a set has no go (or no no-go)
+// trials, the other rate is used alone.
+var balanced_accuracy = function (go_trials, nogo_trials) {
+    var rates = [];
+    if (go_trials.length > 0)
+        rates.push(proportion(go_trials, function (o) { return o.correct === true; }));
+    if (nogo_trials.length > 0)
+        rates.push(proportion(nogo_trials, function (o) { return o.correct === true; }));
+    return mean(rates);
+};
+// Score 0-100 from the hit RT and the balanced accuracy: RT / (acc^5), clamped to 300-5000 ms.
+// Without any hit there is no RT to score, so the score is 0. (Previously an RT of 0 was
+// clamped to the best value, so a participant who never responded scored 100.)
+var calculate_performance_score = function (hit_rt, acc) {
+    if (!(hit_rt > 0)) {
+        return 0;
+    }
+    var performance = hit_rt / (Math.pow(acc, 5) + 0.001);
+    performance = Math.min(Math.max(performance, BEST_SCORE), WORST_SCORE);
+    var performance_score = (1 - ((performance - BEST_SCORE) / (WORST_SCORE - BEST_SCORE))) * 100;
+    return performance_score;
+};
 var gonogo_results = function (data) {
     // throw error if obj is empty
     if (data.length === 0) {
         throw new Error("No trials found");
     }
-    var results = {
-        n: data.length,
-        avg_rt: data.reduce(function (a, b) { return a + b.rt; }, 0) / data.length,
-        avg_acc: data.reduce(function (a, b) { return a + b.correct; }, 0) / data.length,
-        performance: NaN
+    var correct_trials = data.filter(function (o) { return o.correct === true; });
+    var incorrect_trials = data.filter(function (o) { return o.correct === false; });
+    var go_trials = data.filter(function (o) { return o.should_go === true; });
+    var nogo_trials = data.filter(function (o) { return o.should_go === false; });
+    // A response is correct on go trials (hit) and incorrect on no-go trials (false alarm).
+    // Correct no-go trials and missed go trials have no response, so no RT.
+    var hit_rt = mean_rt(go_trials);
+    var balanced_acc = balanced_accuracy(go_trials, nogo_trials);
+    var common = {
+        n_trials: data.length,
+        n_correct_trials: correct_trials.length,
+        n_incorrect_trials: incorrect_trials.length,
+        avg_rt_total: mean_rt(data),
+        avg_rt_correct: mean_rt(correct_trials),
+        avg_rt_incorrect: mean_rt(incorrect_trials),
+        performance_score: calculate_performance_score(hit_rt, balanced_acc)
+    };
+    // Group by block for special results
+    var by_block = Object.values(data.reduce(function (acc, trial) {
+        var key = trial.block_number || 'unknown';
+        if (!acc[key])
+            acc[key] = { block: key, trials: [] };
+        acc[key].trials.push(trial);
+        return acc;
+    }, {})).map(function (group) {
+        var block_go = group.trials.filter(function (o) { return o.should_go === true; });
+        var block_nogo = group.trials.filter(function (o) { return o.should_go === false; });
+        group.avg_rt = mean_rt(block_go);
+        group.avg_acc = proportion(group.trials, function (o) { return o.correct === true; });
+        group.hit_rate = proportion(block_go, function (o) { return o.correct === true; });
+        group.correct_rejection_rate = proportion(block_nogo, function (o) { return o.correct === true; });
+        group.balanced_acc = balanced_accuracy(block_go, block_nogo);
+        return group;
+    });
+    var special = {
+        balanced_acc: balanced_acc,
+        by_block: by_block,
+        go_trials: {
+            n: go_trials.length,
+            avg_rt: hit_rt,
+            avg_acc: proportion(go_trials, function (o) { return o.correct === true; }),
+            n_omissions: go_trials.filter(function (o) { return o.did_go === false; }).length,
+        },
+        nogo_trials: {
+            n: nogo_trials.length,
+            avg_rt: mean_rt(nogo_trials),
+            avg_acc: proportion(nogo_trials, function (o) { return o.correct === true; }),
+            n_commissions: nogo_trials.filter(function (o) { return o.did_go === true; }).length,
+        }
+    };
+    return {
+        common: common,
+        special: special
     };
-    var best_score = 300;
-    var worst_score = 5000;
-    var 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;
 };
 exports.gonogo_results = gonogo_results;

package/dist/cjs/index.d.ts

@@ -1,9 +1,6 @@
-import { NbackResultsStructure } from './nback';
-import { SpatialResultsStructure } from './spatial-cognition';
-import { GonogoResultsStructure } from './gonogo';
-import { EmotionResultsStructure } from './emotions';
+import { NbackResultsStructure, SpatialResultsStructure, GonogoResultsStructure, EmotionResultsStructure, CommonResults } from './common-interfaces';
 declare const NbackResults: (obj: any[]) => NbackResultsStructure;
 declare const SpatialCognitionResults: (obj: any[]) => SpatialResultsStructure;
 declare const GonogoResults: (obj: any[]) => GonogoResultsStructure;
 declare const EmotionResults: (obj: any[]) => EmotionResultsStructure;
-export { NbackResults, SpatialCognitionResults, EmotionResults, GonogoResults };
+export { NbackResults, SpatialCognitionResults, EmotionResults, GonogoResults, NbackResultsStructure, SpatialResultsStructure, GonogoResultsStructure, EmotionResultsStructure, CommonResults };

package/dist/cjs/nback.d.ts

@@ -1,15 +1,9 @@
+import { NbackResultsStructure, NbackGroupResults, NbackBlockResults, NbackLevelResults } from './common-interfaces';
 declare const nback_calculate_results: (obj: any[]) => NbackResultsStructure;
 declare const nback_extract_trials: (obj: any[]) => any[];
-interface NbackTrialResultsStructure {
-    n: number;
-    avg_rt: number;
-    avg_acc: number;
-}
-interface NbackResultsStructure {
-    total_trials: NbackTrialResultsStructure;
-    target_trials: NbackTrialResultsStructure;
-    non_target_trials: NbackTrialResultsStructure;
-    performance: number;
-}
 declare const nback_results: (trials: any[]) => NbackResultsStructure;
-export { nback_extract_trials, nback_results, nback_calculate_results, NbackResultsStructure };
+declare const inverse_normal: (p: number) => number;
+declare const nback_group_results: (trials: any[]) => NbackGroupResults;
+declare const nback_results_by_block: (trials: any[]) => NbackBlockResults[];
+declare const nback_results_by_nback: (trials: any[]) => NbackLevelResults[];
+export { nback_extract_trials, nback_results, nback_calculate_results, nback_group_results, nback_results_by_block, nback_results_by_nback, inverse_normal, NbackResultsStructure };

package/dist/cjs/nback.js

@@ -1,12 +1,33 @@
 "use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.nback_calculate_results = exports.nback_results = exports.nback_extract_trials = void 0;
+exports.inverse_normal = exports.nback_results_by_nback = exports.nback_results_by_block = exports.nback_group_results = exports.nback_calculate_results = exports.nback_results = exports.nback_extract_trials = void 0;
 // from the passed json extract those objects that have field is_target
+// Version 1 trials have no n_back field and get exactly the original result. Version 2 trials
+// (n_back, block, block_index on each trial) also get special.by_block and special.by_nback.
 var nback_calculate_results = function (obj) {
     var trials = nback_extract_trials(obj);
-    return nback_results(trials);
+    var results = nback_results(trials);
+    if (nback_is_versioned(trials)) {
+        results.special.by_block = nback_results_by_block(trials);
+        results.special.by_nback = nback_results_by_nback(trials);
+    }
+    return results;
 };
 exports.nback_calculate_results = nback_calculate_results;
+var nback_is_versioned = function (trials) {
+    return trials.some(function (t) { return t.n_back !== undefined && t.n_back !== null; });
+};
 var nback_extract_trials = function (obj) {
     var trials = obj.filter(function (o) { return 'is_target' in o; });
     return trials;
@@ -15,26 +36,149 @@ exports.nback_extract_trials = nback_extract_trials;
 var nback_results = function (trials) {
     var target_trials = trials.filter(function (o) { return o.is_target; });
     var non_target_trials = trials.filter(function (o) { return !o.is_target; });
-    var results = {
-        total_trials: {
-            n: trials.length,
-            avg_rt: trials.reduce(function (a, b) { return a + b.rt; }, 0) / trials.length,
-            avg_acc: trials.reduce(function (a, b) { return a + b.correct; }, 0) / trials.length,
-        },
+    var correct_trials = trials.filter(function (o) { return o.correct === true; });
+    var incorrect_trials = trials.filter(function (o) { return o.correct === false; });
+    var total_rt = trials.reduce(function (a, b) { return a + (b.rt || 0); }, 0);
+    var correct_rt = correct_trials.reduce(function (a, b) { return a + (b.rt || 0); }, 0);
+    var incorrect_rt = incorrect_trials.reduce(function (a, b) { return a + (b.rt || 0); }, 0);
+    var responded_trials = trials.filter(function (o) { return o.response !== null; });
+    var correct_responded_trials = responded_trials.filter(function (o) { return o.correct === true; });
+    var incorrect_responded_trials = responded_trials.filter(function (o) { return o.correct === false; });
+    var common = {
+        n_trials: trials.length,
+        n_correct_trials: correct_trials.length,
+        n_incorrect_trials: incorrect_trials.length,
+        avg_rt_total: trials.length > 0 ? total_rt / responded_trials.length : 0,
+        avg_rt_correct: correct_trials.length > 0 ? correct_rt / correct_responded_trials.length : 0,
+        avg_rt_incorrect: incorrect_trials.length > 0 ? incorrect_rt / incorrect_responded_trials.length : 0,
+        performance_score: trials.length > 0 ? correct_trials.length * 100 / trials.length : 0
+    };
+    var special = {
         target_trials: {
             n: target_trials.length,
-            avg_rt: target_trials.reduce(function (a, b) { return a + b.rt; }, 0) / target_trials.length,
-            avg_acc: target_trials.reduce(function (a, b) { return a + b.correct; }, 0) / target_trials.length,
+            avg_rt: target_trials.length > 0 ? target_trials.reduce(function (a, b) { return a + (b.rt || 0); }, 0) / target_trials.length : 0,
+            avg_acc: target_trials.length > 0 ? target_trials.reduce(function (a, b) { return a + (b.correct ? 1 : 0); }, 0) * 100 / target_trials.length : 0,
         },
         non_target_trials: {
             n: non_target_trials.length,
-            avg_rt: non_target_trials.reduce(function (a, b) { return a + b.rt; }, 0) / non_target_trials.length,
-            avg_acc: non_target_trials.reduce(function (a, b) { return a + b.correct; }, 0) / non_target_trials.length,
-        },
-        performance: NaN
+            avg_rt: non_target_trials.length > 0 ? non_target_trials.reduce(function (a, b) { return a + (b.rt || 0); }, 0) / non_target_trials.length : 0,
+            avg_acc: non_target_trials.length > 0 ? non_target_trials.reduce(function (a, b) { return a + (b.correct ? 1 : 0); }, 0) * 100 / non_target_trials.length : 0,
+        }
+    };
+    var results = {
+        common: common,
+        special: special
     };
-    results.performance = results.total_trials.avg_acc;
     console.log(results);
     return results;
 };
 exports.nback_results = nback_results;
+// Standard normal CDF (Marsaglia 2004, Taylor series; absolute error ~1e-15 for |x| < 8)
+var normal_cdf = function (x) {
+    var sum = x, term = x, prev = 0;
+    var x2 = x * x;
+    for (var i = 3; sum !== prev; i += 2) {
+        prev = sum;
+        term *= x2 / i;
+        sum = prev + term;
+    }
+    return 0.5 + sum * Math.exp(-0.5 * x2 - 0.91893853320467274178);
+};
+// Inverse of the standard normal CDF: Acklam's rational approximation, polished with one
+// Halley step against normal_cdf, as Acklam recommends. Accurate to ~1e-12 for 1e-10 < p < 1 - 1e-10.
+var inverse_normal = function (p) {
+    if (p <= 0)
+        return -Infinity;
+    if (p >= 1)
+        return Infinity;
+    var x = acklam_inverse_normal(p);
+    var e = normal_cdf(x) - p;
+    var u = e * Math.sqrt(2 * Math.PI) * Math.exp(x * x / 2);
+    return x - u / (1 + x * u / 2);
+};
+exports.inverse_normal = inverse_normal;
+var acklam_inverse_normal = function (p) {
+    var a = [-3.969683028665376e+01, 2.209460984245205e+02, -2.759285104469687e+02,
+        1.383577518672690e+02, -3.066479806614716e+01, 2.506628277459239e+00];
+    var b = [-5.447609879822406e+01, 1.615858368580409e+02, -1.556989798598866e+02,
+        6.680131188771972e+01, -1.328068155288572e+01];
+    var c = [-7.784894002430293e-03, -3.223964580411365e-01, -2.400758277161838e+00,
+        -2.549671010322563e+00, 4.374664141464968e+00, 2.938163982698783e+00];
+    var d = [7.784695709041462e-03, 3.224671290700398e-01, 2.445134137142996e+00,
+        3.754408661907416e+00];
+    var p_low = 0.02425;
+    if (p < p_low) {
+        var q_1 = Math.sqrt(-2 * Math.log(p));
+        return (((((c[0] * q_1 + c[1]) * q_1 + c[2]) * q_1 + c[3]) * q_1 + c[4]) * q_1 + c[5]) /
+            ((((d[0] * q_1 + d[1]) * q_1 + d[2]) * q_1 + d[3]) * q_1 + 1);
+    }
+    if (p > 1 - p_low)
+        return -acklam_inverse_normal(1 - p);
+    var q = p - 0.5;
+    var r = q * q;
+    return (((((a[0] * r + a[1]) * r + a[2]) * r + a[3]) * r + a[4]) * r + a[5]) * q /
+        (((((b[0] * r + b[1]) * r + b[2]) * r + b[3]) * r + b[4]) * r + 1);
+};
+var mean_or_null = function (xs) {
+    return xs.length > 0 ? xs.reduce(function (s, x) { return s + x; }, 0) / xs.length : null;
+};
+var responded = function (t) { return t.response !== null && t.response !== undefined; };
+// d' uses the log-linear correction (Hautus 1995), so it stays finite at 0 % or 100 % rates
+var nback_group_results = function (trials) {
+    var targets = trials.filter(function (t) { return t.is_target; });
+    var non_targets = trials.filter(function (t) { return !t.is_target; });
+    var hits = targets.filter(responded);
+    var false_alarms = non_targets.filter(responded);
+    var lures = non_targets.filter(function (t) { return t.is_lure === true; });
+    var lure_false_alarms = lures.filter(responded).length;
+    var n_correct = trials.filter(function (t) { return t.correct === true; }).length;
+    var rts = function (ts) { return ts.map(function (t) { return t.rt; }).filter(function (rt) { return typeof rt === 'number'; }); };
+    return {
+        n_trials: trials.length,
+        n_correct_trials: n_correct,
+        performance_score: trials.length > 0 ? n_correct * 100 / trials.length : 0,
+        n_targets: targets.length,
+        n_non_targets: non_targets.length,
+        hits: hits.length,
+        misses: targets.length - hits.length,
+        false_alarms: false_alarms.length,
+        correct_rejections: non_targets.length - false_alarms.length,
+        hit_rate: targets.length > 0 ? hits.length / targets.length : null,
+        false_alarm_rate: non_targets.length > 0 ? false_alarms.length / non_targets.length : null,
+        d_prime: targets.length > 0 && non_targets.length > 0
+            ? inverse_normal((hits.length + 0.5) / (targets.length + 1))
+                - inverse_normal((false_alarms.length + 0.5) / (non_targets.length + 1))
+            : null,
+        n_lures: lures.length,
+        lure_false_alarms: lure_false_alarms,
+        lure_false_alarm_rate: lures.length > 0 ? lure_false_alarms / lures.length : null,
+        avg_rt_hits: mean_or_null(rts(hits)),
+        avg_rt_false_alarms: mean_or_null(rts(false_alarms)),
+    };
+};
+exports.nback_group_results = nback_group_results;
+var nback_results_by_block = function (trials) {
+    var blocks = new Map();
+    for (var _i = 0, trials_1 = trials; _i < trials_1.length; _i++) {
+        var t = trials_1[_i];
+        if (!blocks.has(t.block_index))
+            blocks.set(t.block_index, []);
+        blocks.get(t.block_index).push(t);
+    }
+    return Array.from(blocks.entries())
+        .sort(function (_a, _b) {
+        var a = _a[0];
+        var b = _b[0];
+        return a - b;
+    })
+        .map(function (_a) {
+        var block_index = _a[0], ts = _a[1];
+        return (__assign({ block: ts[0].block, block_index: block_index, n_back: ts[0].n_back }, nback_group_results(ts)));
+    });
+};
+exports.nback_results_by_block = nback_results_by_block;
+var nback_results_by_nback = function (trials) {
+    var levels = Array.from(new Set(trials.map(function (t) { return t.n_back; }))).sort(function (a, b) { return a - b; });
+    return levels.map(function (n_back) { return (__assign({ n_back: n_back }, nback_group_results(trials.filter(function (t) { return t.n_back === n_back; })))); });
+};
+exports.nback_results_by_nback = nback_results_by_nback;

package/dist/cjs/spatial-cognition.d.ts

@@ -1,9 +1,4 @@
-interface SpatialResultsStructure {
-    n: number;
-    avg_rt: number;
-    avg_acc: number;
-    performance: number;
-}
+import { SpatialResultsStructure } from './common-interfaces';
 declare const spatial_calculate_results: (obj: any[]) => SpatialResultsStructure;
 declare const spatial_extract_trials: (obj: any[]) => any[];
 declare const spatial_results: (obj: any[]) => SpatialResultsStructure;

package/dist/cjs/spatial-cognition.js

@@ -1,11 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.spatial_calculate_results = exports.spatial_results = exports.spatial_extract_trials = exports.spatial_extract_image_info = void 0;
+var BEST_SCORE = 1000;
+var WORST_SCORE = 10000;
 var spatial_calculate_results = function (obj) {
     var trials = spatial_extract_trials(obj);
     return spatial_results(trials);
 };
 exports.spatial_calculate_results = spatial_calculate_results;
+var calculate_performance_score = function (avg_rt, avg_acc) {
+    var performance = avg_rt / (avg_acc + 0.001);
+    performance = Math.min(Math.max(performance, BEST_SCORE), WORST_SCORE);
+    var performance_score = (1 - ((performance - BEST_SCORE) / (WORST_SCORE - BEST_SCORE))) * 100;
+    return performance_score;
+};
 var spatial_extract_trials = function (obj) {
     var trials = obj.filter(function (o) { return 'stimulus' in o &&
         o.stimulus.startsWith("<img src="); });
@@ -14,21 +22,66 @@ var spatial_extract_trials = function (obj) {
 };
 exports.spatial_extract_trials = spatial_extract_trials;
 var spatial_results = function (obj) {
-    var results = {
-        n: obj.length,
-        avg_rt: obj.reduce(function (a, b) { return a + b.rt; }, 0) / obj.length,
-        avg_acc: obj.reduce(function (a, b) { return a + b.correct; }, 0) / obj.length,
-        performance: NaN
+    var correct_trials = obj.filter(function (o) { return o.correct === 1 || o.correct === true; });
+    var incorrect_trials = obj.filter(function (o) { return o.correct === 0 || o.correct === false; });
+    var total_rt = obj.reduce(function (a, b) { return a + (b.rt || 0); }, 0);
+    var correct_rt = correct_trials.reduce(function (a, b) { return a + (b.rt || 0); }, 0);
+    var incorrect_rt = incorrect_trials.reduce(function (a, b) { return a + (b.rt || 0); }, 0);
+    var avg_rt = obj.length > 0 ? total_rt / obj.length : 0;
+    var avg_acc = obj.length > 0 ? correct_trials.length / obj.length : 0;
+    var performance_score = calculate_performance_score(avg_rt, avg_acc);
+    var common = {
+        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: performance_score
+    };
+    // Group by distance, angle, and rotation for special results
+    var by_distance = Object.values(obj.reduce(function (acc, trial) {
+        var key = trial.distance || 'unknown';
+        if (!acc[key])
+            acc[key] = { distance: key, trials: [], avg_rt: 0, avg_acc: 0 };
+        acc[key].trials.push(trial);
+        return acc;
+    }, {})).map(function (group) {
+        group.avg_rt = group.trials.reduce(function (a, b) { return a + (b.rt || 0); }, 0) / group.trials.length;
+        group.avg_acc = group.trials.reduce(function (a, b) { return a + (b.correct ? 1 : 0); }, 0) / group.trials.length;
+        return group;
+    });
+    var by_angle = Object.values(obj.reduce(function (acc, trial) {
+        var key = trial.angle || 'unknown';
+        if (!acc[key])
+            acc[key] = { angle: key, trials: [], avg_rt: 0, avg_acc: 0 };
+        acc[key].trials.push(trial);
+        return acc;
+    }, {})).map(function (group) {
+        group.avg_rt = group.trials.reduce(function (a, b) { return a + (b.rt || 0); }, 0) / group.trials.length;
+        group.avg_acc = group.trials.reduce(function (a, b) { return a + (b.correct ? 1 : 0); }, 0) / group.trials.length;
+        return group;
+    });
+    var by_rotation = Object.values(obj.reduce(function (acc, trial) {
+        var key = trial.rotation || 'unknown';
+        if (!acc[key])
+            acc[key] = { rotation: key, trials: [], avg_rt: 0, avg_acc: 0 };
+        acc[key].trials.push(trial);
+        return acc;
+    }, {})).map(function (group) {
+        group.avg_rt = group.trials.reduce(function (a, b) { return a + (b.rt || 0); }, 0) / group.trials.length;
+        group.avg_acc = group.trials.reduce(function (a, b) { return a + (b.correct ? 1 : 0); }, 0) / group.trials.length;
+        return group;
+    });
+    var special = {
+        by_distance: by_distance,
+        by_angle: by_angle,
+        by_rotation: by_rotation
+    };
+    return {
+        common: common,
+        special: special
     };
-    var best_score = 1000;
-    var worst_score = 10000;
-    // results.avg_acc to the power of 5
-    //let performance = results.avg_rt / (Math.pow(results.avg_acc, 5) + 0.001);
-    var performance = results.avg_rt / (results.avg_acc + 0.001);
-    performance = Math.min(Math.max(performance, best_score), 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;
 };
 exports.spatial_results = spatial_results;
 var spatial_extract_image_info = function (obj) {

package/dist/esm/common-interfaces.d.ts

@@ -0,0 +1,92 @@
+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 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;
+    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;
+    };
+    by_block?: NbackBlockResults[];
+    by_nback?: NbackLevelResults[];
+}
+interface SpatialSpecialResults {
+    by_distance: any[];
+    by_angle: any[];
+    by_rotation: any[];
+}
+interface GonogoSpecialResults {
+    balanced_acc: number;
+    by_block: any[];
+    go_trials: {
+        n: number;
+        avg_rt: number;
+        avg_acc: number;
+        n_omissions: number;
+    };
+    nogo_trials: {
+        n: number;
+        avg_rt: number;
+        avg_acc: number;
+        n_commissions: 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, NbackGroupResults, NbackBlockResults, NbackLevelResults, SpatialSpecialResults, GonogoSpecialResults, EmotionSpecialResults };

package/dist/esm/common-interfaces.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/emotions.d.ts

@@ -1,10 +1,5 @@
-interface EmotionResultsStructure {
-    n: number;
-    avg_rt: number;
-    avg_acc: number;
-    performance: number;
-}
+import { EmotionResultsStructure } from './common-interfaces';
 declare const emotion_calculate_results: (obj: any[]) => EmotionResultsStructure;
-declare const emotion_results: (obj: any[]) => EmotionResultsStructure;
 declare const emotion_extract_trials: (obj: any[]) => any[];
+declare const emotion_results: (obj: any[]) => EmotionResultsStructure;
 export { EmotionResultsStructure, emotion_calculate_results, emotion_extract_trials, emotion_results };