URL of experiment: https://pavlovia.org/run/avinhcado/image_trial_vinh/html/
Description of the problem:
Hi guys, I’m trying to pilot an my voice response experiment online and I keep getting this issue
Uncaught SyntaxError: Unexpected token ‘{’
I’m not much a coder so I’ve been struggling where in my script I have to fix, if someone could help me that’d be great!
/********************
* Imagetrial1 Test *
********************/
import { PsychoJS } from './lib/core-2020.1.js';
import * as core from './lib/core-2020.1.js';
import { TrialHandler } from './lib/data-2020.1.js';
import { Scheduler } from './lib/util-2020.1.js';
import * as util from './lib/util-2020.1.js';
import * as visual from './lib/visual-2020.1.js';
import * as sound from './lib/sound-2020.1.js';
// init psychoJS:
const psychoJS = new PsychoJS({
debug: true
});
// open window:
psychoJS.openWindow({
fullscr: true,
color: new util.Color([0, 0, 0]),
units: 'height',
waitBlanking: true
});
// store info about the experiment session:
let expName = 'imagetrial1'; // from the Builder filename that created this script
let expInfo = {'participant': '', 'session': '001'};
// schedule the experiment:
psychoJS.schedule(psychoJS.gui.DlgFromDict({
dictionary: expInfo,
title: expName
}));
const flowScheduler = new Scheduler(psychoJS);
const dialogCancelScheduler = new Scheduler(psychoJS);
psychoJS.scheduleCondition(function() { return (psychoJS.gui.dialogComponent.button === 'OK'); }, flowScheduler, dialogCancelScheduler);
// flowScheduler gets run if the participants presses OK
flowScheduler.add(updateInfo); // add timeStamp
flowScheduler.add(experimentInit);
flowScheduler.add(instrRoutineBegin());
flowScheduler.add(instrRoutineEachFrame());
flowScheduler.add(instrRoutineEnd());
flowScheduler.add(targetRoutineBegin());
flowScheduler.add(targetRoutineEachFrame());
flowScheduler.add(targetRoutineEnd());
const trialsLoopScheduler = new Scheduler(psychoJS);
flowScheduler.add(trialsLoopBegin, trialsLoopScheduler);
flowScheduler.add(trialsLoopScheduler);
flowScheduler.add(trialsLoopEnd);
flowScheduler.add(endRoutineBegin());
flowScheduler.add(endRoutineEachFrame());
flowScheduler.add(endRoutineEnd());
flowScheduler.add(quitPsychoJS, '', true);
// quit if user presses Cancel in dialog box:
dialogCancelScheduler.add(quitPsychoJS, '', false);
psychoJS.start({
expName: expName,
expInfo: expInfo,
});
function updateInfo() {
expInfo['date'] = util.MonotonicClock.getDateStr(); // add a simple timestamp
expInfo['expName'] = expName;
expInfo['psychopyVersion'] = '2020.1.2';
expInfo['OS'] = window.navigator.platform;
// store frame rate of monitor if we can measure it successfully
expInfo['frameRate'] = psychoJS.window.getActualFrameRate();
if (typeof expInfo['frameRate'] !== 'undefined')
frameDur = 1.0 / Math.round(expInfo['frameRate']);
else
frameDur = 1.0 / 60.0; // couldn't get a reliable measure so guess
// add info from the URL:
util.addInfoFromUrl(expInfo);
return Scheduler.Event.NEXT;
}
function experimentInit() {
// Initialize components for Routine "instr"
instrClock = new util.Clock();
instrText = new visual.TextStim({
win: psychoJS.window,
name: 'instrText',
text: 'INSTRUCTIONS:\n\nYou will be shown a series of images \n\nPlease try to vocally NAME/IDENTIFY the object/stimuli as fast as possible\n\nYour voice will be recorded\n\nPress SPACE to start, once you have understood the instructions\n',
font: 'Arial',
units: undefined,
pos: [0, 0], height: 0.25, wrapWidth: undefined, ori: 0,
color: new util.Color('white'), opacity: 1,
depth: 0.0
});
instrResp = new core.Keyboard({psychoJS: psychoJS, clock: new util.Clock(), waitForStart: true});
import {prefs} from 'psychopy';
import {sound} from 'psychopy';
import * as vk from 'psychopy/voicekey';
import {DemoVoiceKeySignal as Signaler} from 'psychopy/voicekey/demo_vks';
prefs.hardware["audioLib"] = ["PTB"];
new vk.PTB_init({"rate": 44100, "buffersize": 32});
// Initialize components for Routine "target"
targetClock = new util.Clock();
midtarget = new visual.TextStim({
win: psychoJS.window,
name: 'midtarget',
text: '+',
font: 'Arial',
units: undefined,
pos: [0, 0], height: 0.1, wrapWidth: undefined, ori: 0,
color: new util.Color('white'), opacity: 1,
depth: 0.0
});
// Initialize components for Routine "trial"
trialClock = new util.Clock();
trialImg = new visual.ImageStim({
win : psychoJS.window,
name : 'trialImg', units : undefined,
image : stimuli, mask : undefined,
ori : 0, pos : [0, 0], size : [0.5, 0.5],
color : new util.Color([1, 1, 1]), opacity : 1,
flipHoriz : false, flipVert : false,
texRes : 128, interpolate : true, depth : 0.0
});
vpvk = new vk.OnsetVoiceKey({"sec": 2, "file_out": (((("data/trial_" + trials.thisN.toString().zfill(3)) + "_") + word) + ".wav")});
vpvk.start();
// Initialize components for Routine "end"
endClock = new util.Clock();
endText = new visual.TextStim({
win: psychoJS.window,
name: 'endText',
text: 'END OF EXPERIMENT\n\nPlease alert the supervisor\n\nThank you',
font: 'Arial',
units: undefined,
pos: [0, 0], height: 0.1, wrapWidth: undefined, ori: 0,
color: new util.Color('white'), opacity: 1,
depth: 0.0
});
// Create some handy timers
globalClock = new util.Clock(); // to track the time since experiment started
routineTimer = new util.CountdownTimer(); // to track time remaining of each (non-slip) routine
return Scheduler.Event.NEXT;
}
function instrRoutineBegin(trials) {
return function () {
//------Prepare to start Routine 'instr'-------
t = 0;
instrClock.reset(); // clock
frameN = -1;
// update component parameters for each repeat
instrResp.keys = undefined;
instrResp.rt = undefined;
_instrResp_allKeys = [];
// keep track of which components have finished
instrComponents = [];
instrComponents.push(instrText);
instrComponents.push(instrResp);
for (const thisComponent of instrComponents)
if ('status' in thisComponent)
thisComponent.status = PsychoJS.Status.NOT_STARTED;
return Scheduler.Event.NEXT;
};
}
function instrRoutineEachFrame(trials) {
return function () {
//------Loop for each frame of Routine 'instr'-------
let continueRoutine = true; // until we're told otherwise
// get current time
t = instrClock.getTime();
frameN = frameN + 1;// number of completed frames (so 0 is the first frame)
// update/draw components on each frame
// *instrText* updates
if (t >= 0.0 && instrText.status === PsychoJS.Status.NOT_STARTED) {
// keep track of start time/frame for later
instrText.tStart = t; // (not accounting for frame time here)
instrText.frameNStart = frameN; // exact frame index
instrText.setAutoDraw(true);
}
// *instrResp* updates
if (t >= 0.0 && instrResp.status === PsychoJS.Status.NOT_STARTED) {
// keep track of start time/frame for later
instrResp.tStart = t; // (not accounting for frame time here)
instrResp.frameNStart = frameN; // exact frame index
// keyboard checking is just starting
psychoJS.window.callOnFlip(function() { instrResp.clock.reset(); }); // t=0 on next screen flip
psychoJS.window.callOnFlip(function() { instrResp.start(); }); // start on screen flip
psychoJS.window.callOnFlip(function() { instrResp.clearEvents(); });
}
if (instrResp.status === PsychoJS.Status.STARTED) {
let theseKeys = instrResp.getKeys({keyList: ['space'], waitRelease: false});
_instrResp_allKeys = _instrResp_allKeys.concat(theseKeys);
if (_instrResp_allKeys.length > 0) {
instrResp.keys = _instrResp_allKeys[_instrResp_allKeys.length - 1].name; // just the last key pressed
instrResp.rt = _instrResp_allKeys[_instrResp_allKeys.length - 1].rt;
// a response ends the routine
continueRoutine = false;
}
}
// check for quit (typically the Esc key)
if (psychoJS.experiment.experimentEnded || psychoJS.eventManager.getKeys({keyList:['escape']}).length > 0) {
return quitPsychoJS('The [Escape] key was pressed. Goodbye!', false);
}
// check if the Routine should terminate
if (!continueRoutine) { // a component has requested a forced-end of Routine
return Scheduler.Event.NEXT;
}
continueRoutine = false; // reverts to True if at least one component still running
for (const thisComponent of instrComponents)
if ('status' in thisComponent && thisComponent.status !== PsychoJS.Status.FINISHED) {
continueRoutine = true;
break;
}
// refresh the screen if continuing
if (continueRoutine) {
return Scheduler.Event.FLIP_REPEAT;
} else {
return Scheduler.Event.NEXT;
}
};
}
function instrRoutineEnd(trials) {
return function () {
//------Ending Routine 'instr'-------
for (const thisComponent of instrComponents) {
if (typeof thisComponent.setAutoDraw === 'function') {
thisComponent.setAutoDraw(false);
}
}
psychoJS.experiment.addData('instrResp.keys', instrResp.keys);
if (typeof instrResp.keys !== 'undefined') { // we had a response
psychoJS.experiment.addData('instrResp.rt', instrResp.rt);
routineTimer.reset();
}
instrResp.stop();
// the Routine "instr" was not non-slip safe, so reset the non-slip timer
routineTimer.reset();
return Scheduler.Event.NEXT;
};
}
function targetRoutineBegin(trials) {
return function () {
//------Prepare to start Routine 'target'-------
t = 0;
targetClock.reset(); // clock
frameN = -1;
routineTimer.add(2.000000);
// update component parameters for each repeat
// keep track of which components have finished
targetComponents = [];
targetComponents.push(midtarget);
for (const thisComponent of targetComponents)
if ('status' in thisComponent)
thisComponent.status = PsychoJS.Status.NOT_STARTED;
return Scheduler.Event.NEXT;
};
}
function targetRoutineEachFrame(trials) {
return function () {
//------Loop for each frame of Routine 'target'-------
let continueRoutine = true; // until we're told otherwise
// get current time
t = targetClock.getTime();
frameN = frameN + 1;// number of completed frames (so 0 is the first frame)
// update/draw components on each frame
// *midtarget* updates
if (t >= 0.0 && midtarget.status === PsychoJS.Status.NOT_STARTED) {
// keep track of start time/frame for later
midtarget.tStart = t; // (not accounting for frame time here)
midtarget.frameNStart = frameN; // exact frame index
midtarget.setAutoDraw(true);
}
frameRemains = 0.0 + 2 - psychoJS.window.monitorFramePeriod * 0.75; // most of one frame period left
if (midtarget.status === PsychoJS.Status.STARTED && t >= frameRemains) {
midtarget.setAutoDraw(false);
}
// check for quit (typically the Esc key)
if (psychoJS.experiment.experimentEnded || psychoJS.eventManager.getKeys({keyList:['escape']}).length > 0) {
return quitPsychoJS('The [Escape] key was pressed. Goodbye!', false);
}
// check if the Routine should terminate
if (!continueRoutine) { // a component has requested a forced-end of Routine
return Scheduler.Event.NEXT;
}
continueRoutine = false; // reverts to True if at least one component still running
for (const thisComponent of targetComponents)
if ('status' in thisComponent && thisComponent.status !== PsychoJS.Status.FINISHED) {
continueRoutine = true;
break;
}
// refresh the screen if continuing
if (continueRoutine && routineTimer.getTime() > 0) {
return Scheduler.Event.FLIP_REPEAT;
} else {
return Scheduler.Event.NEXT;
}
};
}
function targetRoutineEnd(trials) {
return function () {
//------Ending Routine 'target'-------
for (const thisComponent of targetComponents) {
if (typeof thisComponent.setAutoDraw === 'function') {
thisComponent.setAutoDraw(false);
}
}
return Scheduler.Event.NEXT;
};
}
function trialsLoopBegin(thisScheduler) {
// set up handler to look after randomisation of conditions etc
trials = new TrialHandler({
psychoJS: psychoJS,
nReps: 20, method: TrialHandler.Method.RANDOM,
extraInfo: expInfo, originPath: undefined,
trialList: '../../things_database copy/image_paths.csv',
seed: undefined, name: 'trials'
});
psychoJS.experiment.addLoop(trials); // add the loop to the experiment
currentLoop = trials; // we're now the current loop
// Schedule all the trials in the trialList:
for (const thisTrial of trials) {
const snapshot = trials.getSnapshot();
thisScheduler.add(importConditions(snapshot));
thisScheduler.add(trialRoutineBegin(snapshot));
thisScheduler.add(trialRoutineEachFrame(snapshot));
thisScheduler.add(trialRoutineEnd(snapshot));
thisScheduler.add(endLoopIteration(thisScheduler, snapshot));
}
return Scheduler.Event.NEXT;
}
function trialsLoopEnd() {
psychoJS.experiment.removeLoop(trials);
return Scheduler.Event.NEXT;
}
function trialRoutineBegin(trials) {
return function () {
//------Prepare to start Routine 'trial'-------
t = 0;
trialClock.reset(); // clock
frameN = -1;
routineTimer.add(5.000000);
// update component parameters for each repeat
vpvk.start();
vpvk.tStart = trialClock.getTime();
// keep track of which components have finished
trialComponents = [];
trialComponents.push(trialImg);
for (const thisComponent of trialComponents)
if ('status' in thisComponent)
thisComponent.status = PsychoJS.Status.NOT_STARTED;
return Scheduler.Event.NEXT;
};
}
function trialRoutineEachFrame(trials) {
return function () {
//------Loop for each frame of Routine 'trial'-------
let continueRoutine = true; // until we're told otherwise
// get current time
t = trialClock.getTime();
frameN = frameN + 1;// number of completed frames (so 0 is the first frame)
// update/draw components on each frame
// *trialImg* updates
if (t >= 0.0 && trialImg.status === PsychoJS.Status.NOT_STARTED) {
// keep track of start time/frame for later
trialImg.tStart = t; // (not accounting for frame time here)
trialImg.frameNStart = frameN; // exact frame index
trialImg.setAutoDraw(true);
}
frameRemains = 0.0 + 5 - psychoJS.window.monitorFramePeriod * 0.75; // most of one frame period left
if (trialImg.status === PsychoJS.Status.STARTED && t >= frameRemains) {
trialImg.setAutoDraw(false);
}
// check for quit (typically the Esc key)
if (psychoJS.experiment.experimentEnded || psychoJS.eventManager.getKeys({keyList:['escape']}).length > 0) {
return quitPsychoJS('The [Escape] key was pressed. Goodbye!', false);
}
// check if the Routine should terminate
if (!continueRoutine) { // a component has requested a forced-end of Routine
return Scheduler.Event.NEXT;
}
continueRoutine = false; // reverts to True if at least one component still running
for (const thisComponent of trialComponents)
if ('status' in thisComponent && thisComponent.status !== PsychoJS.Status.FINISHED) {
continueRoutine = true;
break;
}
// refresh the screen if continuing
if (continueRoutine && routineTimer.getTime() > 0) {
return Scheduler.Event.FLIP_REPEAT;
} else {
return Scheduler.Event.NEXT;
}
};
}
function trialRoutineEnd(trials) {
return function () {
//------Ending Routine 'trial'-------
for (const thisComponent of trialComponents) {
if (typeof thisComponent.setAutoDraw === 'function') {
thisComponent.setAutoDraw(false);
}
}
thisExp.addData("RecordOnset", vpvk.tStart);
thisExp.addData("WordOnset", Stimuli.tStart);
return Scheduler.Event.NEXT;
};
}
function endRoutineBegin(trials) {
return function () {
//------Prepare to start Routine 'end'-------
t = 0;
endClock.reset(); // clock
frameN = -1;
routineTimer.add(20.000000);
// update component parameters for each repeat
// keep track of which components have finished
endComponents = [];
endComponents.push(endText);
for (const thisComponent of endComponents)
if ('status' in thisComponent)
thisComponent.status = PsychoJS.Status.NOT_STARTED;
return Scheduler.Event.NEXT;
};
}
function endRoutineEachFrame(trials) {
return function () {
//------Loop for each frame of Routine 'end'-------
let continueRoutine = true; // until we're told otherwise
// get current time
t = endClock.getTime();
frameN = frameN + 1;// number of completed frames (so 0 is the first frame)
// update/draw components on each frame
// *endText* updates
if (t >= 0.0 && endText.status === PsychoJS.Status.NOT_STARTED) {
// keep track of start time/frame for later
endText.tStart = t; // (not accounting for frame time here)
endText.frameNStart = frameN; // exact frame index
endText.setAutoDraw(true);
}
frameRemains = 0.0 + 20 - psychoJS.window.monitorFramePeriod * 0.75; // most of one frame period left
if (endText.status === PsychoJS.Status.STARTED && t >= frameRemains) {
endText.setAutoDraw(false);
}
// check for quit (typically the Esc key)
if (psychoJS.experiment.experimentEnded || psychoJS.eventManager.getKeys({keyList:['escape']}).length > 0) {
return quitPsychoJS('The [Escape] key was pressed. Goodbye!', false);
}
// check if the Routine should terminate
if (!continueRoutine) { // a component has requested a forced-end of Routine
return Scheduler.Event.NEXT;
}
continueRoutine = false; // reverts to True if at least one component still running
for (const thisComponent of endComponents)
if ('status' in thisComponent && thisComponent.status !== PsychoJS.Status.FINISHED) {
continueRoutine = true;
break;
}
// refresh the screen if continuing
if (continueRoutine && routineTimer.getTime() > 0) {
return Scheduler.Event.FLIP_REPEAT;
} else {
return Scheduler.Event.NEXT;
}
};
}
function endRoutineEnd(trials) {
return function () {
//------Ending Routine 'end'-------
for (const thisComponent of endComponents) {
if (typeof thisComponent.setAutoDraw === 'function') {
thisComponent.setAutoDraw(false);
}
}
return Scheduler.Event.NEXT;
};
}
function endLoopIteration(thisScheduler, loop) {
// ------Prepare for next entry------
return function () {
if (typeof loop !== 'undefined') {
// ------Check if user ended loop early------
if (loop.finished) {
// Check for and save orphaned data
if (psychoJS.experiment.isEntryEmpty()) {
psychoJS.experiment.nextEntry(loop);
}
thisScheduler.stop();
} else {
const thisTrial = loop.getCurrentTrial();
if (typeof thisTrial === 'undefined' || !('isTrials' in thisTrial) || thisTrial.isTrials) {
psychoJS.experiment.nextEntry(loop);
}
}
return Scheduler.Event.NEXT;
}
};
}
function importConditions(trials) {
return function () {
psychoJS.importAttributes(trials.getCurrentTrial());
return Scheduler.Event.NEXT;
};
}
function quitPsychoJS(message, isCompleted) {
// Check for and save orphaned data
if (psychoJS.experiment.isEntryEmpty()) {
psychoJS.experiment.nextEntry();
}
psychoJS.window.close();
psychoJS.quit({message: message, isCompleted: isCompleted});
return Scheduler.Event.QUIT;
}