@nandanvasudevan thanks for contributing,

Please read Contribution Guidelines and runstandard --fix command
Thank you
@itsvinayak

This is all kinds of wrong.

Your class isn't a singleton becausethis.instance always refers tothis and not the class itself.

a=newIntervalTimer()b=newIntervalTimer()console.log(a===b)// false

A way to make a singleton that is close to what you wrote would be

classIntervalTimer{constructor(){if(IntervalTimer.instance)returnIntervalTimer.instance// ... rest of constructor here}}

Also, there is no reason to make it a singleton since JS supports very well having multiplesetInterval running concurrently, so your description is wrong:

The class is singleton as javascript does not support multiple timer instances

You don't actually measure time elapsed:setInterval returns an ID meant to be passed toclearInterval and isn't specifically related to any time measurements. This logic is wrong ingetRunTime as well as ingetElapsedTime:

startTimer(){this.timer=setInterval(this.callBack,this.interval)}/**  *@return {number} Elapsed time since start.  */getRunTime(){returnthis.timer}

On a more conceptual level,setInterval isn't particularly well suited to keep track of time because it can be delayed arbitrarily. One should prefer thePerformance API if possible (ES, but not Node). If your context doesn't have theperformance object, you can replaceperformance.now() withDate.now() in each of the following examples (which will result in a slightly less accurate interval).

The best pure-JS interval will always have to be blocking (in which case making it a singleton makes sense), but that's only useable in a threaded context (like a web worker or worker thread) because it blocks the execution of anything else.

classBlockingInterval{constructor(callback=()=>{},interval=0){if(BlockingInterval.instance)returnBlockingInterval.instancethis.callback=callbackthis.interval=intervalthis.click(this.interval)}click(interval,start=performance.now()){while(performance.now()-start<interval){}this.callback()this.click(interval,start+interval)}}letlast=performance.now()consta=newBlockingInterval(()=>{constcurrent=performance.now()console.log(current-last)last=current},500)

If you need an interval for drawing in the browser, use the same principle but withrequestAnimationFrame. It will be less precise but as close as can be to a browser frame:

classFrameInterval{constructor(callback=()=>{},interval=0){this.callback=callbackthis.click(interval)}asyncclick(interval,start=performance.now()){while(performance.now()-start<interval){awaitnewPromise(requestAnimationFrame)}this.callback()this.click(interval,start+interval)}}letlast=performance.now()consta=newFrameInterval(()=>{constcurrent=performance.now()console.log(current-last)last=current},500)

If you are more concerned w/ the average interval being correct, you should use asetTimeout and adjust the delay on each iteration:

classDriftCompensatedInterval{constructor(callback=()=>{},interval=0){this.callback=callbackthis.interval=intervalthis.click()}click(drift=0){conststart=performance.now()setTimeout(()=>{this.callback()this.click((performance.now()-start)-this.interval)},this.interval-drift)}}letlast=performance.now()consta=newDriftCompensatedInterval(()=>{constcurrent=performance.now()console.log(current-last)last=current},500)

I didn't know about any of these. Thanks for pointing it out.
I will start working on the fix.