//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
(function(global, module, define) {
function Alea(seed) {
var me = this, mash = Mash();
me.next = function() {
var t = 2091639 * me.s0 + me.c * 2.3283064365386963e-10; // 2^-32
me.s0 = me.s1;
me.s1 = me.s2;
return me.s2 = t - (me.c = t | 0);
};
// Apply the seeding algorithm from Baagoe.
me.c = 1;
me.s0 = mash(' ');
me.s1 = mash(' ');
me.s2 = mash(' ');
me.s0 -= mash(seed);
if (me.s0 < 0) { me.s0 += 1; }
me.s1 -= mash(seed);
if (me.s1 < 0) { me.s1 += 1; }
me.s2 -= mash(seed);
if (me.s2 < 0) { me.s2 += 1; }
mash = null;
}
function copy(f, t) {
t.c = f.c;
t.s0 = f.s0;
t.s1 = f.s1;
t.s2 = f.s2;
return t;
}
function impl(seed, opts) {
var xg = new Alea(seed),
state = opts && opts.state,
prng = xg.next;
prng.int32 = function() { return (xg.next() * 0x100000000) | 0; };
prng.double = function() {
return prng() + (prng() * 0x200000 | 0) * 1.1102230246251565e-16; // 2^-53
};
prng.quick = prng;
if (state) {
if (typeof(state) == 'object') copy(state, xg);
prng.state = function() { return copy(xg, {}); };
}
return prng;
}
function Mash() {
var n = 0xefc8249d;
var mash = function(data) {
data = String(data);
for (var i = 0; i < data.length; i++) {
n += data.charCodeAt(i);
var h = 0.02519603282416938 * n;
n = h >>> 0;
h -= n;
h *= n;
n = h >>> 0;
h -= n;
n += h * 0x100000000; // 2^32
}
return (n >>> 0) * 2.3283064365386963e-10; // 2^-32
};
return mash;
}
if (module && module.exports) {
module.exports = impl;
} else if (define && define.amd) {
define(function() { return impl; });
} else {
this.alea = impl;
}
})(
commonjsGlobal,
module, // present in node.js
(typeof undefined) == 'function' // present with an AMD loader
);
} (alea));
var seedrandom = alea.exports;
/**
* Uses the `seedrandom` package to replace Math.random() with a seedable PRNG.
*
* @param seed An optional seed. If none is given, a random seed will be generated.
* @returns The seed value.
*/
function setSeed(seed = Math.random().toString()) {
Math.random = seedrandom(seed);
return seed;
}
function repeat(array, repetitions, unpack = false) {
const arr_isArray = Array.isArray(array);
const rep_isArray = Array.isArray(repetitions);
// if array is not an array, then we just repeat the item
if (!arr_isArray) {
if (!rep_isArray) {
array = [array];
repetitions = [repetitions];
}
else {
repetitions = [repetitions[0]];
console.log("Unclear parameters given to randomization.repeat. Multiple set sizes specified, but only one item exists to sample. Proceeding using the first set size.");
}
}
else {
// if repetitions is not an array, but array is, then we
// repeat repetitions for each entry in array
if (!rep_isArray) {
let reps = [];
for (let i = 0; i < array.length; i++) {
reps.push(repetitions);
}
repetitions = reps;
}
else {
if (array.length != repetitions.length) {
console.warn("Unclear parameters given to randomization.repeat. Items and repetitions are unequal lengths. Behavior may not be as expected.");
// throw warning if repetitions is too short, use first rep ONLY.
if (repetitions.length < array.length) {
let reps = [];
for (let i = 0; i < array.length; i++) {
reps.push(repetitions);
}
repetitions = reps;
}
else {
// throw warning if too long, and then use the first N
repetitions = repetitions.slice(0, array.length);
}
}
}
}
// should be clear at this point to assume that array and repetitions are arrays with == length
let allsamples = [];
for (let i = 0; i < array.length; i++) {
for (let j = 0; j < repetitions[i]; j++) {
if (array[i] == null || typeof array[i] != "object") {
allsamples.push(array[i]);
}
else {
allsamples.push(Object.assign({}, array[i]));
}
}
}
let out = shuffle(allsamples);
if (unpack) {
out = unpackArray(out);
}
return out;
}
function shuffle(array) {
if (!Array.isArray(array)) {
console.error("Argument to shuffle() must be an array.");
}
const copy_array = array.slice(0);
let m = copy_array.length, t, i;
// While there remain elements to shuffle…
while (m) {
// Pick a remaining element…
i = Math.floor(Math.random() * m--);
// And swap it with the current element.
t = copy_array[m];
copy_array[m] = copy_array[i];
copy_array[i] = t;
}
return copy_array;
}
function shuffleNoRepeats(arr, equalityTest) {
if (!Array.isArray(arr)) {
console.error("First argument to shuffleNoRepeats() must be an array.");
}
if (typeof equalityTest !== "undefined" && typeof equalityTest !== "function") {
console.error("Second argument to shuffleNoRepeats() must be a function.");
}
// define a default equalityTest
if (typeof equalityTest == "undefined") {
equalityTest = function (a, b) {
if (a === b) {
return true;
}
else {
return false;
}
};
}
const random_shuffle = shuffle(arr);
for (let i = 0; i < random_shuffle.length - 1; i++) {
if (equalityTest(random_shuffle[i], random_shuffle[i + 1])) {
// neighbors are equal, pick a new random neighbor to swap (not the first or last element, to avoid edge cases)
let random_pick = Math.floor(Math.random() * (random_shuffle.length - 2)) + 1;
// test to make sure the new neighbor isn't equal to the old one
while (equalityTest(random_shuffle[i + 1], random_shuffle[random_pick]) ||
equalityTest(random_shuffle[i + 1], random_shuffle[random_pick + 1]) ||
equalityTest(random_shuffle[i + 1], random_shuffle[random_pick - 1])) {
random_pick = Math.floor(Math.random() * (random_shuffle.length - 2)) + 1;
}
const new_neighbor = random_shuffle[random_pick];
random_shuffle[random_pick] = random_shuffle[i + 1];
random_shuffle[i + 1] = new_neighbor;
}
}
return random_shuffle;
}
function shuffleAlternateGroups(arr_groups, random_group_order = false) {
const n_groups = arr_groups.length;
if (n_groups == 1) {
console.warn("shuffleAlternateGroups() was called with only one group. Defaulting to simple shuffle.");
return shuffle(arr_groups[0]);
}
let group_order = [];
for (let i = 0; i < n_groups; i++) {
group_order.push(i);
}
if (random_group_order) {
group_order = shuffle(group_order);
}
const randomized_groups = [];
let min_length = null;
for (let i = 0; i < n_groups; i++) {
min_length =
min_length === null ? arr_groups[i].length : Math.min(min_length, arr_groups[i].length);
randomized_groups.push(shuffle(arr_groups[i]));
}
const out = [];
for (let i = 0; i < min_length; i++) {
for (let j = 0; j < group_order.length; j++) {
out.push(randomized_groups[group_order[j]][i]);
}
}
return out;
}
function sampleWithoutReplacement(arr, size) {
if (!Array.isArray(arr)) {
console.error("First argument to sampleWithoutReplacement() must be an array");
}
if (size > arr.length) {
console.error("Cannot take a sample larger than the size of the set of items to sample.");
}
return shuffle(arr).slice(0, size);
}
function sampleWithReplacement(arr, size, weights) {
if (!Array.isArray(arr)) {
console.error("First argument to sampleWithReplacement() must be an array");
}
const normalized_weights = [];
if (typeof weights !== "undefined") {
if (weights.length !== arr.length) {
console.error("The length of the weights array must equal the length of the array " +
"to be sampled from.");
}
let weight_sum = 0;
for (const weight of weights) {
weight_sum += weight;
}
for (const weight of weights) {
normalized_weights.push(weight / weight_sum);
}
}
else {
for (let i = 0; i < arr.length; i++) {
normalized_weights.push(1 / arr.length);
}
}
const cumulative_weights = [normalized_weights[0]];
for (let i = 1; i < normalized_weights.length; i++) {
cumulative_weights.push(normalized_weights[i] + cumulative_weights[i - 1]);
}
const samp = [];
for (let i = 0; i < size; i++) {
const rnd = Math.random();
let index = 0;
while (rnd > cumulative_weights[index]) {
index++;
}
samp.push(arr[index]);
}
return samp;
}
function factorial(factors, repetitions = 1, unpack = false) {
let design = [{}];
for (const [factorName, factor] of Object.entries(factors)) {
const new_design = [];
for (const level of factor) {
for (const cell of design) {
new_design.push(Object.assign(Object.assign({}, cell), { [factorName]: level }));
}
}
design = new_design;
}
return repeat(design, repetitions, unpack);
}
function randomID(length = 32) {
let result = "";
const chars = "0123456789abcdefghjklmnopqrstuvwxyz";
for (let i = 0; i < length; i++) {
result += chars[Math.floor(Math.random() * chars.length)];
}
return result;
}
/**
* Generate a random integer from `lower` to `upper`, inclusive of both end points.
* @param lower The lowest value it is possible to generate
* @param upper The highest value it is possible to generate
* @returns A random integer
*/
function randomInt(lower, upper) {
if (upper < lower) {
throw new Error("Upper boundary must be less than or equal to lower boundary");
}
return lower + Math.floor(Math.random() * (upper - lower + 1));
}
/**
* Generates a random sample from a Bernoulli distribution.
* @param p The probability of sampling 1.
* @returns 0, with probability 1-p, or 1, with probability p.
*/
function sampleBernoulli(p) {
return Math.random() <= p ? 1 : 0;
}
function sampleNormal(mean, standard_deviation) {
return randn_bm() * standard_deviation + mean;
}
function sampleExponential(rate) {
return -Math.log(Math.random()) / rate;
}
function sampleExGaussian(mean, standard_deviation, rate, positive = false) {
let s = sampleNormal(mean, standard_deviation) + sampleExponential(rate);
if (positive) {
while (s <= 0) {
s = sampleNormal(mean, standard_deviation) + sampleExponential(rate);
}
}
return s;
}
/**
* Generate one or more random words.
*
* This is a wrapper function for the {@link https://www.npmjs.com/package/random-words `random-words` npm package}.
*
* @param opts An object with optional properties `min`, `max`, `exactly`,
* `join`, `maxLength`, `wordsPerString`, `separator`, and `formatter`.
*
* @returns An array of words or a single string, depending on parameter choices.
*/
function randomWords(opts) {
return randomWords$1(opts);
}
// Box-Muller transformation for a random sample from normal distribution with mean = 0, std = 1
// https://stackoverflow.com/a/36481059/3726673
function randn_bm() {
var u = 0, v = 0;
while (u === 0)
u = Math.random(); //Converting [0,1) to (0,1)
while (v === 0)
v = Math.random();
return Math.sqrt(-2.0 * Math.log(u)) * Math.cos(2.0 * Math.PI * v);
}
function unpackArray(array) {
const out = {};
for (const x of array) {
for (const key of Object.keys(x)) {
if (typeof out[key] === "undefined") {
out[key] = [];
}
out[key].push(x[key]);
}
}
return out;
}
var randomization = /*#__PURE__*/Object.freeze({
__proto__: null,
setSeed: setSeed,
repeat: repeat,
shuffle: shuffle,
shuffleNoRepeats: shuffleNoRepeats,
shuffleAlternateGroups: shuffleAlternateGroups,
sampleWithoutReplacement: sampleWithoutReplacement,
sampleWithReplacement: sampleWithReplacement,
factorial: factorial,
randomID: randomID,
randomInt: randomInt,
sampleBernoulli: sampleBernoulli,
sampleNormal: sampleNormal,
sampleExponential: sampleExponential,
sampleExGaussian: sampleExGaussian,
randomWords: randomWords
});
/**
* Gets information about the Mechanical Turk Environment, HIT, Assignment, and Worker
* by parsing the URL variables that Mechanical Turk generates.
* @returns An object containing information about the Mechanical Turk Environment, HIT, Assignment, and Worker.
*/
function turkInfo() {
const turk = {
previewMode: false,
outsideTurk: false,
hitId: "INVALID_URL_PARAMETER",
assignmentId: "INVALID_URL_PARAMETER",
workerId: "INVALID_URL_PARAMETER",
turkSubmitTo: "INVALID_URL_PARAMETER",
};
const param = function (url, name) {
name = name.replace(/[\[]/, "\\[").replace(/[\]]/, "\\]");
const regexS = "[\\?&]" + name + "=([^&#]*)";
const regex = new RegExp(regexS);
const results = regex.exec(url);
return results == null ? "" : results[1];
};
const src = param(window.location.href, "assignmentId")
? window.location.href
: document.referrer;
const keys = ["assignmentId", "hitId", "workerId", "turkSubmitTo"];
keys.map(function (key) {
turk[key] = unescape(param(src, key));
});
turk.previewMode = turk.assignmentId == "ASSIGNMENT_ID_NOT_AVAILABLE";
turk.outsideTurk =
!turk.previewMode && turk.hitId === "" && turk.assignmentId == "" && turk.workerId == "";
return turk;
}
/**
* Send data to Mechnical Turk for storage.
* @param data An object containing `key:value` pairs to send to Mechanical Turk. Values
* cannot contain nested objects, arrays, or functions.
* @returns Nothing
*/
function submitToTurk(data) {
const turk = turkInfo();
const assignmentId = turk.assignmentId;
const turkSubmitTo = turk.turkSubmitTo;
if (!assignmentId || !turkSubmitTo)
return;
const form = document.createElement("form");
form.method = "POST";
form.action = turkSubmitTo + "/mturk/externalSubmit?assignmentId=" + assignmentId;
for (const key in data) {
if (data.hasOwnProperty(key)) {
const hiddenField = document.createElement("input");
hiddenField.type = "hidden";
hiddenField.name = key;
hiddenField.id = key;
hiddenField.value = data[key];
form.appendChild(hiddenField);
}
}
document.body.appendChild(form);
form.submit();
}
var turk = /*#__PURE__*/Object.freeze({
__proto__: null,
turkInfo: turkInfo,
submitToTurk: submitToTurk
});
class TimelineNode {
// constructor
constructor(jsPsych, parameters, parent, relativeID) {
this.jsPsych = jsPsych;
// track progress through the node
this.progress = {
current_location: -1,
current_variable_set: 0,
current_repetition: 0,
current_iteration: 0,
done: false,
};
// store a link to the parent of this node
this.parent_node = parent;
// create the ID for this node
this.relative_id = typeof parent === "undefined" ? 0 : relativeID;
// check if there is a timeline parameter
// if there is, then this node has its own timeline
if (typeof parameters.timeline !== "undefined") {
// create timeline properties
this.timeline_parameters = {
timeline: [],
loop_function: parameters.loop_function,
conditional_function: parameters.conditional_function,
sample: parameters.sample,
randomize_order: typeof parameters.randomize_order == "undefined" ? false : parameters.randomize_order,
repetitions: typeof parameters.repetitions == "undefined" ? 1 : parameters.repetitions,
timeline_variables: typeof parameters.timeline_variables == "undefined"
? [{}]
: parameters.timeline_variables,
on_timeline_finish: parameters.on_timeline_finish,
on_timeline_start: parameters.on_timeline_start,
};
this.setTimelineVariablesOrder();
// extract all of the node level data and parameters
// but remove all of the timeline-level specific information
// since this will be used to copy things down hierarchically
var node_data = Object.assign({}, parameters);
delete node_data.timeline;
delete node_data.conditional_function;
delete node_data.loop_function;
delete node_data.randomize_order;
delete node_data.repetitions;
delete node_data.timeline_variables;
delete node_data.sample;
delete node_data.on_timeline_start;
delete node_data.on_timeline_finish;
this.node_trial_data = node_data; // store for later...
// create a TimelineNode for each element in the timeline
for (var i = 0; i < parameters.timeline.length; i++) {
// merge parameters
var merged_parameters = Object.assign({}, node_data, parameters.timeline[i]);
// merge any data from the parent node into child nodes
if (typeof node_data.data == "object" && typeof parameters.timeline[i].data == "object") {
var merged_data = Object.assign({}, node_data.data, parameters.timeline[i].data);
merged_parameters.data = merged_data;
}
this.timeline_parameters.timeline.push(new TimelineNode(this.jsPsych, merged_parameters, this, i));
}
}
// if there is no timeline parameter, then this node is a trial node
else {
// check to see if a valid trial type is defined
if (typeof parameters.type === "undefined") {
console.error('Trial level node is missing the "type" parameter. The parameters for the node are: ' +
JSON.stringify(parameters));
}
// create a deep copy of the parameters for the trial
this.trial_parameters = Object.assign({}, parameters);
}
}
// recursively get the next trial to run.
// if this node is a leaf (trial), then return the trial.
// otherwise, recursively find the next trial in the child timeline.
trial() {
if (typeof this.timeline_parameters == "undefined") {
// returns a clone of the trial_parameters to
// protect functions.
return deepCopy(this.trial_parameters);
}
else {
if (this.progress.current_location >= this.timeline_parameters.timeline.length) {
return null;
}
else {
return this.timeline_parameters.timeline[this.progress.current_location].trial();
}
}
}
markCurrentTrialComplete() {
if (typeof this.timeline_parameters === "undefined") {
this.progress.done = true;
}
else {
this.timeline_parameters.timeline[this.progress.current_location].markCurrentTrialComplete();
}
}
nextRepetiton() {
this.setTimelineVariablesOrder();
this.progress.current_location = -1;
this.progress.current_variable_set = 0;
this.progress.current_repetition++;
for (var i = 0; i < this.timeline_parameters.timeline.length; i++) {
this.timeline_parameters.timeline[i].reset();
}
}
// set the order for going through the timeline variables array
setTimelineVariablesOrder() {
const timeline_parameters = this.timeline_parameters;
// check to make sure this node has variables
if (typeof timeline_parameters === "undefined" ||
typeof timeline_parameters.timeline_variables === "undefined") {
return;
}
var order = [];
for (var i = 0; i < timeline_parameters.timeline_variables.length; i++) {
order.push(i);
}
if (typeof timeline_parameters.sample !== "undefined") {
if (timeline_parameters.sample.type == "custom") {
order = timeline_parameters.sample.fn(order);
}
else if (timeline_parameters.sample.type == "with-replacement") {
order = sampleWithReplacement(order, timeline_parameters.sample.size, timeline_parameters.sample.weights);
}
else if (timeline_parameters.sample.type == "without-replacement") {
order = sampleWithoutReplacement(order, timeline_parameters.sample.size);
}
else if (timeline_parameters.sample.type == "fixed-repetitions") {
order = repeat(order, timeline_parameters.sample.size, false);
}
else if (timeline_parameters.sample.type == "alternate-groups") {
order = shuffleAlternateGroups(timeline_parameters.sample.groups, timeline_parameters.sample.randomize_group_order);
}
else {
console.error('Invalid type in timeline sample parameters. Valid options for type are "custom", "with-replacement", "without-replacement", "fixed-repetitions", and "alternate-groups"');
}
}
if (timeline_parameters.randomize_order) {
order = shuffle(order);
}
this.progress.order = order;
}
// next variable set
nextSet() {
this.progress.current_location = -1;
this.progress.current_variable_set++;
for (var i = 0; i < this.timeline_parameters.timeline.length; i++) {
this.timeline_parameters.timeline[i].reset();
}
}
// update the current trial node to be completed
// returns true if the node is complete after advance (all subnodes are also complete)
// returns false otherwise
advance() {
const progress = this.progress;
const timeline_parameters = this.timeline_parameters;
const internal = this.jsPsych.internal;
// first check to see if done
if (progress.done) {
return true;
}
// if node has not started yet (progress.current_location == -1),
// then try to start the node.
if (progress.current_location == -1) {
// check for on_timeline_start and conditonal function on nodes with timelines
if (typeof timeline_parameters !== "undefined") {
// only run the conditional function if this is the first repetition of the timeline when
// repetitions > 1, and only when on the first variable set
if (typeof timeline_parameters.conditional_function !== "undefined" &&
progress.current_repetition == 0 &&
progress.current_variable_set == 0) {
internal.call_immediate = true;
var conditional_result = timeline_parameters.conditional_function();
internal.call_immediate = false;
// if the conditional_function() returns false, then the timeline
// doesn't run and is marked as complete.
if (conditional_result == false) {
progress.done = true;
return true;
}
}
// if we reach this point then the node has its own timeline and will start
// so we need to check if there is an on_timeline_start function if we are on the first variable set
if (typeof timeline_parameters.on_timeline_start !== "undefined" &&
progress.current_variable_set == 0) {
timeline_parameters.on_timeline_start();
}
}
// if we reach this point, then either the node doesn't have a timeline of the
// conditional function returned true and it can start
progress.current_location = 0;
// call advance again on this node now that it is pointing to a new location
return this.advance();
}
// if this node has a timeline, propogate down to the current trial.
if (typeof timeline_parameters !== "undefined") {
var have_node_to_run = false;
// keep incrementing the location in the timeline until one of the nodes reached is incomplete
while (progress.current_location < timeline_parameters.timeline.length &&
have_node_to_run == false) {
// check to see if the node currently pointed at is done
var target_complete = timeline_parameters.timeline[progress.current_location].advance();
if (!target_complete) {
have_node_to_run = true;
return false;
}
else {
progress.current_location++;
}
}
// if we've reached the end of the timeline (which, if the code is here, we have)
// there are a few steps to see what to do next...
// first, check the timeline_variables to see if we need to loop through again
// with a new set of variables
if (progress.current_variable_set < progress.order.length - 1) {
// reset the progress of the node to be with the new set
this.nextSet();
// then try to advance this node again.
return this.advance();
}
// if we're all done with the timeline_variables, then check to see if there are more repetitions
else if (progress.current_repetition < timeline_parameters.repetitions - 1) {
this.nextRepetiton();
// check to see if there is an on_timeline_finish function
if (typeof timeline_parameters.on_timeline_finish !== "undefined") {
timeline_parameters.on_timeline_finish();
}
return this.advance();
}
// if we're all done with the repetitions...
else {
// check to see if there is an on_timeline_finish function
if (typeof timeline_parameters.on_timeline_finish !== "undefined") {
timeline_parameters.on_timeline_finish();
}
// if we're all done with the repetitions, check if there is a loop function.
if (typeof timeline_parameters.loop_function !== "undefined") {
internal.call_immediate = true;
if (timeline_parameters.loop_function(this.generatedData())) {
this.reset();
internal.call_immediate = false;
return this.parent_node.advance();
}
else {
progress.done = true;
internal.call_immediate = false;
return true;
}
}
}
// no more loops on this timeline, we're done!
progress.done = true;
return true;
}
}
// check the status of the done flag
isComplete() {
return this.progress.done;
}
// getter method for timeline variables
getTimelineVariableValue(variable_name) {
if (typeof this.timeline_parameters == "undefined") {
return undefined;
}
var v = this.timeline_parameters.timeline_variables[this.progress.order[this.progress.current_variable_set]][variable_name];
return v;
}
// recursive upward search for timeline variables
findTimelineVariable(variable_name) {
var v = this.getTimelineVariableValue(variable_name);
if (typeof v == "undefined") {
if (typeof this.parent_node !== "undefined") {
return this.parent_node.findTimelineVariable(variable_name);
}
else {
return undefined;
}
}
else {
return v;
}
}
// recursive downward search for active trial to extract timeline variable
timelineVariable(variable_name) {
if (typeof this.timeline_parameters == "undefined") {
return this.findTimelineVariable(variable_name);
}
else {
// if progress.current_location is -1, then the timeline variable is being evaluated
// in a function that runs prior to the trial starting, so we should treat that trial
// as being the active trial for purposes of finding the value of the timeline variable
var loc = Math.max(0, this.progress.current_location);
// if loc is greater than the number of elements on this timeline, then the timeline
// variable is being evaluated in a function that runs after the trial on the timeline
// are complete but before advancing to the next (like a loop_function).
// treat the last active trial as the active trial for this purpose.
if (loc == this.timeline_parameters.timeline.length) {
loc = loc - 1;
}
// now find the variable
return this.timeline_parameters.timeline[loc].timelineVariable(variable_name);
}
}
// recursively get all the timeline variables for this trial
allTimelineVariables() {
var all_tvs = this.allTimelineVariablesNames();
var all_tvs_vals = {};
for (var i = 0; i < all_tvs.length; i++) {
all_tvs_vals[all_tvs[i]] = this.timelineVariable(all_tvs[i]);
}
return all_tvs_vals;
}
// helper to get all the names at this stage.
allTimelineVariablesNames(so_far = []) {
if (typeof this.timeline_parameters !== "undefined") {
so_far = so_far.concat(Object.keys(this.timeline_parameters.timeline_variables[this.progress.order[this.progress.current_variable_set]]));
// if progress.current_location is -1, then the timeline variable is being evaluated
// in a function that runs prior to the trial starting, so we should treat that trial
// as being the active trial for purposes of finding the value of the timeline variable
var loc = Math.max(0, this.progress.current_location);
// if loc is greater than the number of elements on this timeline, then the timeline
// variable is being evaluated in a function that runs after the trial on the timeline
// are complete but before advancing to the next (like a loop_function).
// treat the last active trial as the active trial for this purpose.
if (loc == this.timeline_parameters.timeline.length) {
loc = loc - 1;
}
// now find the variable
return this.timeline_parameters.timeline[loc].allTimelineVariablesNames(so_far);
}
if (typeof this.timeline_parameters == "undefined") {
return so_far;
}
}
// recursively get the number of **trials** contained in the timeline
// assuming that while loops execute exactly once and if conditionals
// always run
length() {
var length = 0;
if (typeof this.timeline_parameters !== "undefined") {
for (var i = 0; i < this.timeline_parameters.timeline.length; i++) {
length += this.timeline_parameters.timeline[i].length();
}
}
else {
return 1;
}
return length;
}
// return the percentage of trials completed, grouped at the first child level
// counts a set of trials as complete when the child node is done
percentComplete() {
var total_trials = this.length();
var completed_trials = 0;
for (var i = 0; i < this.timeline_parameters.timeline.length; i++) {
if (this.timeline_parameters.timeline[i].isComplete()) {
completed_trials += this.timeline_parameters.timeline[i].length();
}
}
return (completed_trials / total_trials) * 100;
}
// resets the node and all subnodes to original state
// but increments the current_iteration counter
reset() {
this.progress.current_location = -1;
this.progress.current_repetition = 0;
this.progress.current_variable_set = 0;
this.progress.current_iteration++;
this.progress.done = false;
this.setTimelineVariablesOrder();
if (typeof this.timeline_parameters != "undefined") {
for (var i = 0; i < this.timeline_parameters.timeline.length; i++) {
this.timeline_parameters.timeline[i].reset();
}
}
}
// mark this node as finished
end() {
this.progress.done = true;
}
// recursively end whatever sub-node is running the current trial
endActiveNode() {
if (typeof this.timeline_parameters == "undefined") {
this.end();
this.parent_node.end();
}
else {
this.timeline_parameters.timeline[this.progress.current_location].endActiveNode();
}
}
// get a unique ID associated with this node
// the ID reflects the current iteration through this node.
ID() {
var id = "";
if (typeof this.parent_node == "undefined") {
return "0." + this.progress.current_iteration;
}
else {
id += this.parent_node.ID() + "-";
id += this.relative_id + "." + this.progress.current_iteration;
return id;
}
}
// get the ID of the active trial
activeID() {
if (typeof this.timeline_parameters == "undefined") {
return this.ID();
}
else {
return this.timeline_parameters.timeline[this.progress.current_location].activeID();
}
}
// get all the data generated within this node
generatedData() {
return this.jsPsych.data.getDataByTimelineNode(this.ID());
}
// get all the trials of a particular type
trialsOfType(type) {
if (typeof this.timeline_parameters == "undefined") {
if (this.trial_parameters.type == type) {
return this.trial_parameters;
}
else {
return [];
}
}
else {
var trials = [];
for (var i = 0; i < this.timeline_parameters.timeline.length; i++) {
var t = this.timeline_parameters.timeline[i].trialsOfType(type);
trials = trials.concat(t);
}
return trials;
}
}
// add new trials to end of this timeline
insert(parameters) {
if (typeof this.timeline_parameters === "undefined") {
console.error("Cannot add new trials to a trial-level node.");
}
else {
this.timeline_parameters.timeline.push(new TimelineNode(this.jsPsych, Object.assign(Object.assign({}, this.node_trial_data), parameters), this, this.timeline_parameters.timeline.length));
}
}
}
function delay(ms) {
return new Promise((resolve) => setTimeout(resolve, ms));
}
class JsPsych {
constructor(options) {
this.extensions = {};
this.turk = turk;
this.randomization = randomization;
this.utils = utils;
//
// private variables
//
/**
* options
*/
this.opts = {};
// flow control
this.global_trial_index = 0;
this.current_trial = {};
this.current_trial_finished = false;
/**
* is the experiment paused?
*/
this.paused = false;
this.waiting = false;
/**
* is the page retrieved directly via file:// protocol (true) or hosted on a server (false)?
*/
this.file_protocol = false;
/**
* is the experiment running in `simulate()` mode
*/
this.simulation_mode = null;
// storing a single webaudio context to prevent problems with multiple inits
// of jsPsych
this.webaudio_context = null;
this.internal = {
/**
* this flag is used to determine whether we are in a scope where
* jsPsych.timelineVariable() should be executed immediately or
* whether it should return a function to access the variable later.
*
**/
call_immediate: false,
};
this.progress_bar_amount = 0;
// override default options if user specifies an option
options = Object.assign({ display_element: undefined, on_finish: () => { }, on_trial_start: () => { }, on_trial_finish: () => { }, on_data_update: () => { }, on_interaction_data_update: () => { }, on_close: () => { }, use_webaudio: true, exclusions: {}, show_progress_bar: false, message_progress_bar: "Completion Progress", auto_update_progress_bar: true, default_iti: 0, minimum_valid_rt: 0, experiment_width: null, override_safe_mode: false, case_sensitive_responses: false, extensions: [] }, options);
this.opts = options;
autoBind(this); // so we can pass JsPsych methods as callbacks and `this` remains the JsPsych instance
this.webaudio_context =
typeof window !== "undefined" && typeof window.AudioContext !== "undefined"
? new AudioContext()
: null;
// detect whether page is running in browser as a local file, and if so, disable web audio and video preloading to prevent CORS issues
if (window.location.protocol == "file:" &&
(options.override_safe_mode === false || typeof options.override_safe_mode === "undefined")) {
options.use_webaudio = false;
this.file_protocol = true;
console.warn("jsPsych detected that it is running via the file:// protocol and not on a web server. " +
"To prevent issues with cross-origin requests, Web Audio and video preloading have been disabled. " +
"If you would like to override this setting, you can set 'override_safe_mode' to 'true' in initJsPsych. " +
"For more information, see: https://www.jspsych.org/overview/running-experiments");
}
// initialize modules
this.data = new JsPsychData(this);
this.pluginAPI = createJointPluginAPIObject(this);
// create instances of extensions
for (const extension of options.extensions) {
this.extensions[extension.type.info.name] = new extension.type(this);
}
// initialize audio context based on options and browser capabilities
this.pluginAPI.initAudio();
}
version() {
return version;
}
/**
* Starts an experiment using the provided timeline and returns a promise that is resolved when
* the experiment is finished.
*
* @param timeline The timeline to be run
*/
run(timeline) {
return __awaiter(this, void 0, void 0, function* () {
if (typeof timeline === "undefined") {
console.error("No timeline declared in jsPsych.run. Cannot start experiment.");
}
if (timeline.length === 0) {
console.error("No trials have been added to the timeline (the timeline is an empty array). Cannot start experiment.");
}
// create experiment timeline
this.timelineDescription = timeline;
this.timeline = new TimelineNode(this, { timeline });
yield this.prepareDom();
yield this.checkExclusions(this.opts.exclusions);
yield this.loadExtensions(this.opts.extensions);
document.documentElement.setAttribute("jspsych", "present");
this.startExperiment();
yield this.finished;
});
}
simulate(timeline, simulation_mode = "data-only", simulation_options = {}) {
return __awaiter(this, void 0, void 0, function* () {
this.simulation_mode = simulation_mode;
this.simulation_options = simulation_options;
yield this.run(timeline);
});
}
getProgress() {
return {
total_trials: typeof this.timeline === "undefined" ? undefined : this.timeline.length(),
current_trial_global: this.global_trial_index,
percent_complete: typeof this.timeline === "undefined" ? 0 : this.timeline.percentComplete(),
};
}
getStartTime() {
return this.exp_start_time;
}
getTotalTime() {
if (typeof this.exp_start_time === "undefined") {
return 0;
}
return new Date().getTime() - this.exp_start_time.getTime();
}
getDisplayElement() {
return this.DOM_target;
}
getDisplayContainerElement() {
return this.DOM_container;
}
finishTrial(data = {}) {
if (this.current_trial_finished) {
return;
}
this.current_trial_finished = true;
// remove any CSS classes that were added to the DOM via css_classes parameter
if (typeof this.current_trial.css_classes !== "undefined" &&
Array.isArray(this.current_trial.css_classes)) {
this.DOM_target.classList.remove(...this.current_trial.css_classes);
}
// write the data from the trial
this.data.write(data);
// get back the data with all of the defaults in
const trial_data = this.data.getLastTrialData();
// for trial-level callbacks, we just want to pass in a reference to the values
// of the DataCollection, for easy access and editing.
const trial_data_values = trial_data.values()[0];
const current_trial = this.current_trial;
if (typeof current_trial.save_trial_parameters === "object") {
for (const key of Object.keys(current_trial.save_trial_parameters)) {
const key_val = current_trial.save_trial_parameters[key];
if (key_val === true) {
if (typeof current_trial[key] === "undefined") {
console.warn(`Invalid parameter specified in save_trial_parameters. Trial has no property called "${key}".`);
}
else if (typeof current_trial[key] === "function") {
trial_data_values[key] = current_trial[key].toString();
}
else {
trial_data_values[key] = current_trial[key];
}
}
if (key_val === false) {
// we don't allow internal_node_id or trial_index to be deleted because it would break other things
if (key !== "internal_node_id" && key !== "trial_index") {
delete trial_data_values[key];
}
}
}
}
// handle extension callbacks
if (Array.isArray(current_trial.extensions)) {
for (const extension of current_trial.extensions) {
const ext_data_values = this.extensions[extension.type.info.name].on_finish(extension.params);
Object.assign(trial_data_values, ext_data_values);
}
}
// about to execute lots of callbacks, so switch context.
this.internal.call_immediate = true;
// handle callback at plugin level
if (typeof current_trial.on_finish === "function") {
current_trial.on_finish(trial_data_values);
}
// handle callback at whole-experiment level
this.opts.on_trial_finish(trial_data_values);
// after the above callbacks are complete, then the data should be finalized
// for this trial. call the on_data_update handler, passing in the same
// data object that just went through the trial's finish handlers.
this.opts.on_data_update(trial_data_values);
// done with callbacks
this.internal.call_immediate = false;
// wait for iti
if (this.simulation_mode === "data-only") {
this.nextTrial();
}
else if (typeof current_trial.post_trial_gap === null ||
typeof current_trial.post_trial_gap === "undefined") {
if (this.opts.default_iti > 0) {
setTimeout(this.nextTrial, this.opts.default_iti);
}
else {
this.nextTrial();
}
}
else {
if (current_trial.post_trial_gap > 0) {
setTimeout(this.nextTrial, current_trial.post_trial_gap);
}
else {
this.nextTrial();
}
}
}
endExperiment(end_message = "", data = {}) {
this.timeline.end_message = end_message;
this.timeline.end();
this.pluginAPI.cancelAllKeyboardResponses();
this.pluginAPI.clearAllTimeouts();
this.finishTrial(data);
}
endCurrentTimeline() {
this.timeline.endActiveNode();
}
getCurrentTrial() {
return this.current_trial;
}
getInitSettings() {
return this.opts;
}
getCurrentTimelineNodeID() {
return this.timeline.activeID();
}
timelineVariable(varname, immediate = false) {
if (this.internal.call_immediate || immediate === true) {
return this.timeline.timelineVariable(varname);
}
else {
return {
timelineVariablePlaceholder: true,
timelineVariableFunction: () => this.timeline.timelineVariable(varname),
};
}
}
getAllTimelineVariables() {
return this.timeline.allTimelineVariables();
}
addNodeToEndOfTimeline(new_timeline, preload_callback) {
this.timeline.insert(new_timeline);
}
pauseExperiment() {
this.paused = true;
}
resumeExperiment() {
this.paused = false;
if (this.waiting) {
this.waiting = false;
this.nextTrial();
}
}
loadFail(message) {
message = message || "The experiment failed to load.
";
this.DOM_target.innerHTML = message;
}
getSafeModeStatus() {
return this.file_protocol;
}
getTimeline() {
return this.timelineDescription;
}
prepareDom() {
return __awaiter(this, void 0, void 0, function* () {
// Wait until the document is ready
if (document.readyState !== "complete") {
yield new Promise((resolve) => {
window.addEventListener("load", resolve);
});
}
const options = this.opts;
// set DOM element where jsPsych will render content
// if undefined, then jsPsych will use the tag and the entire page
if (typeof options.display_element === "undefined") {
// check if there is a body element on the page
const body = document.querySelector("body");
if (body === null) {
document.documentElement.appendChild(document.createElement("body"));
}
// using the full page, so we need the HTML element to
// have 100% height, and body to be full width and height with
// no margin
document.querySelector("html").style.height = "100%";
document.querySelector("body").style.margin = "0px";
document.querySelector("body").style.height = "100%";
document.querySelector("body").style.width = "100%";
options.display_element = document.querySelector("body");
}
else {
// make sure that the display element exists on the page
const display = options.display_element instanceof Element
? options.display_element
: document.querySelector("#" + options.display_element);
if (display === null) {
console.error("The display_element specified in initJsPsych() does not exist in the DOM.");
}
else {
options.display_element = display;
}
}
options.display_element.innerHTML =
'';
this.DOM_container = options.display_element;
this.DOM_target = document.querySelector("#jspsych-content");
// set experiment_width if not null
if (options.experiment_width !== null) {
this.DOM_target.style.width = options.experiment_width + "px";
}
// add tabIndex attribute to scope event listeners
options.display_element.tabIndex = 0;
// add CSS class to DOM_target
if (options.display_element.className.indexOf("jspsych-display-element") === -1) {
options.display_element.className += " jspsych-display-element";
}
this.DOM_target.className += "jspsych-content";
// create listeners for user browser interaction
this.data.createInteractionListeners();
// add event for closing window
window.addEventListener("beforeunload", options.on_close);
});
}
loadExtensions(extensions) {
return __awaiter(this, void 0, void 0, function* () {
// run the .initialize method of any extensions that are in use
// these should return a Promise to indicate when loading is complete
try {
yield Promise.all(extensions.map((extension) => this.extensions[extension.type.info.name].initialize(extension.params || {})));
}
catch (error_message) {
console.error(error_message);
throw new Error(error_message);
}
});
}
startExperiment() {
this.finished = new Promise((resolve) => {
this.resolveFinishedPromise = resolve;
});
// show progress bar if requested
if (this.opts.show_progress_bar === true) {
this.drawProgressBar(this.opts.message_progress_bar);
}
// record the start time
this.exp_start_time = new Date();
// begin!
this.timeline.advance();
this.doTrial(this.timeline.trial());
}
finishExperiment() {
const finish_result = this.opts.on_finish(this.data.get());
const done_handler = () => {
if (typeof this.timeline.end_message !== "undefined") {
this.DOM_target.innerHTML = this.timeline.end_message;
}
this.resolveFinishedPromise();
};
if (finish_result) {
Promise.resolve(finish_result).then(done_handler);
}
else {
done_handler();
}
}
nextTrial() {
// if experiment is paused, don't do anything.
if (this.paused) {
this.waiting = true;
return;
}
this.global_trial_index++;
// advance timeline
this.timeline.markCurrentTrialComplete();
const complete = this.timeline.advance();
// update progress bar if shown
if (this.opts.show_progress_bar === true && this.opts.auto_update_progress_bar === true) {
this.updateProgressBar();
}
// check if experiment is over
if (complete) {
this.finishExperiment();
return;
}
this.doTrial(this.timeline.trial());
}
doTrial(trial) {
this.current_trial = trial;
this.current_trial_finished = false;
// process all timeline variables for this trial
this.evaluateTimelineVariables(trial);
if (typeof trial.type === "string") {
throw new MigrationError("A string was provided as the trial's `type` parameter. Since jsPsych v7, the `type` parameter needs to be a plugin object.");
}
// instantiate the plugin for this trial
trial.type = Object.assign(Object.assign({}, autoBind(new trial.type(this))), { info: trial.type.info });
// evaluate variables that are functions
this.evaluateFunctionParameters(trial);
// get default values for parameters
this.setDefaultValues(trial);
// about to execute callbacks
this.internal.call_immediate = true;
// call experiment wide callback
this.opts.on_trial_start(trial);
// call trial specific callback if it exists
if (typeof trial.on_start === "function") {
trial.on_start(trial);
}
// call any on_start functions for extensions
if (Array.isArray(trial.extensions)) {
for (const extension of trial.extensions) {
this.extensions[extension.type.info.name].on_start(extension.params);
}
}
// apply the focus to the element containing the experiment.
this.DOM_container.focus();
// reset the scroll on the DOM target
this.DOM_target.scrollTop = 0;
// add CSS classes to the DOM_target if they exist in trial.css_classes
if (typeof trial.css_classes !== "undefined") {
if (!Array.isArray(trial.css_classes) && typeof trial.css_classes === "string") {
trial.css_classes = [trial.css_classes];
}
if (Array.isArray(trial.css_classes)) {
this.DOM_target.classList.add(...trial.css_classes);
}
}
// setup on_load event callback
const load_callback = () => {
if (typeof trial.on_load === "function") {
trial.on_load();
}
// call any on_load functions for extensions
if (Array.isArray(trial.extensions)) {
for (const extension of trial.extensions) {
this.extensions[extension.type.info.name].on_load(extension.params);
}
}
};
let trial_complete;
if (!this.simulation_mode) {
trial_complete = trial.type.trial(this.DOM_target, trial, load_callback);
}
if (this.simulation_mode) {
// check if the trial supports simulation
if (trial.type.simulate) {
let trial_sim_opts;
if (!trial.simulation_options) {
trial_sim_opts = this.simulation_options.default;
}
if (trial.simulation_options) {
if (typeof trial.simulation_options == "string") {
if (this.simulation_options[trial.simulation_options]) {
trial_sim_opts = this.simulation_options[trial.simulation_options];
}
else if (this.simulation_options.default) {
console.log(`No matching simulation options found for "${trial.simulation_options}". Using "default" options.`);
trial_sim_opts = this.simulation_options.default;
}
else {
console.log(`No matching simulation options found for "${trial.simulation_options}" and no "default" options provided. Using the default values provided by the plugin.`);
trial_sim_opts = {};
}
}
else {
trial_sim_opts = trial.simulation_options;
}
}
trial_sim_opts = this.utils.deepCopy(trial_sim_opts);
trial_sim_opts = this.replaceFunctionsWithValues(trial_sim_opts, null);
if ((trial_sim_opts === null || trial_sim_opts === void 0 ? void 0 : trial_sim_opts.simulate) === false) {
trial_complete = trial.type.trial(this.DOM_target, trial, load_callback);
}
else {
trial_complete = trial.type.simulate(trial, (trial_sim_opts === null || trial_sim_opts === void 0 ? void 0 : trial_sim_opts.mode) || this.simulation_mode, trial_sim_opts, load_callback);
}
}
else {
// trial doesn't have a simulate method, so just run as usual
trial_complete = trial.type.trial(this.DOM_target, trial, load_callback);
}
}
// see if trial_complete is a Promise by looking for .then() function
const is_promise = trial_complete && typeof trial_complete.then == "function";
// in simulation mode we let the simulate function call the load_callback always.
if (!is_promise && !this.simulation_mode) {
load_callback();
}
// done with callbacks
this.internal.call_immediate = false;
}
evaluateTimelineVariables(trial) {
for (const key of Object.keys(trial)) {
// timeline variables on the root level
if (typeof trial[key] === "object" &&
trial[key] !== null &&
typeof trial[key].timelineVariablePlaceholder !== "undefined") {
/*trial[key].toString().replace(/\s/g, "") ==
"function(){returntimeline.timelineVariable(varname);}"
)*/ trial[key] = trial[key].timelineVariableFunction();
}
// timeline variables that are nested in objects
if (typeof trial[key] === "object" && trial[key] !== null) {
this.evaluateTimelineVariables(trial[key]);
}
}
}
evaluateFunctionParameters(trial) {
// set a flag so that jsPsych.timelineVariable() is immediately executed in this context
this.internal.call_immediate = true;
// iterate over each parameter
for (const key of Object.keys(trial)) {
// check to make sure parameter is not "type", since that was eval'd above.
if (key !== "type") {
// this if statement is checking to see if the parameter type is expected to be a function, in which case we should NOT evaluate it.
// the first line checks if the parameter is defined in the universalPluginParameters set
// the second line checks the plugin-specific parameters
if (typeof universalPluginParameters[key] !== "undefined" &&
universalPluginParameters[key].type !== exports.ParameterType.FUNCTION) {
trial[key] = this.replaceFunctionsWithValues(trial[key], null);
}
if (typeof trial.type.info.parameters[key] !== "undefined" &&
trial.type.info.parameters[key].type !== exports.ParameterType.FUNCTION) {
trial[key] = this.replaceFunctionsWithValues(trial[key], trial.type.info.parameters[key]);
}
}
}
// reset so jsPsych.timelineVariable() is no longer immediately executed
this.internal.call_immediate = false;
}
replaceFunctionsWithValues(obj, info) {
// null typeof is 'object' (?!?!), so need to run this first!
if (obj === null) {
return obj;
}
// arrays
else if (Array.isArray(obj)) {
for (let i = 0; i < obj.length; i++) {
obj[i] = this.replaceFunctionsWithValues(obj[i], info);
}
}
// objects
else if (typeof obj === "object") {
if (info === null || !info.nested) {
for (const key of Object.keys(obj)) {
if (key === "type") {
// Ignore the object's `type` field because it contains a plugin and we do not want to
// call plugin functions
continue;
}
obj[key] = this.replaceFunctionsWithValues(obj[key], null);
}
}
else {
for (const key of Object.keys(obj)) {
if (typeof info.nested[key] === "object" &&
info.nested[key].type !== exports.ParameterType.FUNCTION) {
obj[key] = this.replaceFunctionsWithValues(obj[key], info.nested[key]);
}
}
}
}
else if (typeof obj === "function") {
return obj();
}
return obj;
}
setDefaultValues(trial) {
for (const param in trial.type.info.parameters) {
// check if parameter is complex with nested defaults
if (trial.type.info.parameters[param].type === exports.ParameterType.COMPLEX) {
if (trial.type.info.parameters[param].array === true) {
// iterate over each entry in the array
trial[param].forEach(function (ip, i) {
// check each parameter in the plugin description
for (const p in trial.type.info.parameters[param].nested) {
if (typeof trial[param][i][p] === "undefined" || trial[param][i][p] === null) {
if (typeof trial.type.info.parameters[param].nested[p].default === "undefined") {
console.error("You must specify a value for the " +
p +
" parameter (nested in the " +
param +
" parameter) in the " +
trial.type +
" plugin.");
}
else {
trial[param][i][p] = trial.type.info.parameters[param].nested[p].default;
}
}
}
});
}
}
// if it's not nested, checking is much easier and do that here:
else if (typeof trial[param] === "undefined" || trial[param] === null) {
if (typeof trial.type.info.parameters[param].default === "undefined") {
console.error("You must specify a value for the " +
param +
" parameter in the " +
trial.type.info.name +
" plugin.");
}
else {
trial[param] = trial.type.info.parameters[param].default;
}
}
}
}
checkExclusions(exclusions) {
return __awaiter(this, void 0, void 0, function* () {
if (exclusions.min_width || exclusions.min_height || exclusions.audio) {
console.warn("The exclusions option in `initJsPsych()` is deprecated and will be removed in a future version. We recommend using the browser-check plugin instead. See https://www.jspsych.org/latest/plugins/browser-check/.");
}
// MINIMUM SIZE
if (exclusions.min_width || exclusions.min_height) {
const mw = exclusions.min_width || 0;
const mh = exclusions.min_height || 0;
if (window.innerWidth < mw || window.innerHeight < mh) {
this.getDisplayElement().innerHTML =
"Your browser window is too small to complete this experiment. " +
"Please maximize the size of your browser window. If your browser window is already maximized, " +
"you will not be able to complete this experiment.
" +
"The minimum width is " +
mw +
"px. Your current width is " +
window.innerWidth +
"px.
" +
"The minimum height is " +
mh +
"px. Your current height is " +
window.innerHeight +
"px.
";
// Wait for window size to increase
while (window.innerWidth < mw || window.innerHeight < mh) {
yield delay(100);
}
this.getDisplayElement().innerHTML = "";
}
}
// WEB AUDIO API
if (typeof exclusions.audio !== "undefined" && exclusions.audio) {
if (!window.hasOwnProperty("AudioContext") && !window.hasOwnProperty("webkitAudioContext")) {
this.getDisplayElement().innerHTML =
"Your browser does not support the WebAudio API, which means that you will not " +
"be able to complete the experiment.
Browsers that support the WebAudio API include " +
"Chrome, Firefox, Safari, and Edge.
";
throw new Error();
}
}
});
}
drawProgressBar(msg) {
document
.querySelector(".jspsych-display-element")
.insertAdjacentHTML("afterbegin", '");
}
updateProgressBar() {
this.setProgressBar(this.getProgress().percent_complete / 100);
}
setProgressBar(proportion_complete) {
proportion_complete = Math.max(Math.min(1, proportion_complete), 0);
document.querySelector("#jspsych-progressbar-inner").style.width =
proportion_complete * 100 + "%";
this.progress_bar_amount = proportion_complete;
}
getProgressBarCompleted() {
return this.progress_bar_amount;
}
}
// __rollup-babel-import-regenerator-runtime__
// temporary patch for Safari
if (typeof window !== "undefined" &&
window.hasOwnProperty("webkitAudioContext") &&
!window.hasOwnProperty("AudioContext")) {
// @ts-expect-error
window.AudioContext = webkitAudioContext;
}
// end patch
// The following function provides a uniform interface to initialize jsPsych, no matter whether a
// browser supports ES6 classes or not (and whether the ES6 build or the Babel build is used).
/**
* Creates a new JsPsych instance using the provided options.
*
* @param options The options to pass to the JsPsych constructor
* @returns A new JsPsych instance
*/
function initJsPsych(options) {
const jsPsych = new JsPsych(options);
// Handle invocations of non-existent v6 methods with migration errors
const migrationMessages = {
init: "`jsPsych.init()` was replaced by `initJsPsych()` in jsPsych v7.",
ALL_KEYS: 'jsPsych.ALL_KEYS was replaced by the "ALL_KEYS" string in jsPsych v7.',
NO_KEYS: 'jsPsych.NO_KEYS was replaced by the "NO_KEYS" string in jsPsych v7.',
// Getter functions that were renamed
currentTimelineNodeID: "`currentTimelineNodeID()` was renamed to `getCurrentTimelineNodeID()` in jsPsych v7.",
progress: "`progress()` was renamed to `getProgress()` in jsPsych v7.",
startTime: "`startTime()` was renamed to `getStartTime()` in jsPsych v7.",
totalTime: "`totalTime()` was renamed to `getTotalTime()` in jsPsych v7.",
currentTrial: "`currentTrial()` was renamed to `getCurrentTrial()` in jsPsych v7.",
initSettings: "`initSettings()` was renamed to `getInitSettings()` in jsPsych v7.",
allTimelineVariables: "`allTimelineVariables()` was renamed to `getAllTimelineVariables()` in jsPsych v7.",
};
Object.defineProperties(jsPsych, Object.fromEntries(Object.entries(migrationMessages).map(([key, message]) => [
key,
{
get() {
throw new MigrationError(message);
},
},
])));
return jsPsych;
}
exports.JsPsych = JsPsych;
exports.initJsPsych = initJsPsych;
exports.universalPluginParameters = universalPluginParameters;
Object.defineProperty(exports, '__esModule', { value: true });
return exports;
})({});
var initJsPsych = jsPsychModule.initJsPsych;