@armniko/ticker - npm Package Compare versions

Comparing version

+1

dist/index.esm.js

+1

dist/index.umd.js

+13

-8

package.json

		{
		"name": "@armniko/ticker",
		"version": "1.0.0",
		"version": "1.1.0",
		"description": "Javascript/typescript library for running app loop with separate logical/drawing ticks and FPS limitation.",
		@@ -15,4 +15,6 @@ "author": "Armīns Nikolajevs <armins.nikolajevs@gmail.com>",
		],
		"main": "dist/index.js",
		"types": "dist/index.d.ts",
		"main": "./dist/index.umd.js",
		"module": "./dist/index.esm.js",
		"typings": "./dist/index.d.ts",
		"type": "module",
		"files": [
		@@ -22,7 +24,7 @@ "dist"
		"scripts": {
		"build": "tsc --project tsconfig.build.json",
		"dev": "node test/server/main.js & tsc --watch",
		"lint": "eslint src --max-warnings=0",
		"build": "rimraf dist && webpack",
		"dev": "node test/server/main.js & webpack --watch",
		"lint": "tsc --noEmit && eslint src --max-warnings=0",
		"lint:fix": "npm run lint -- --fix",
		"test": "jest --runInBand",
		"test": "npm run build && jest",
		"test:coverage": "npm run test -- --collect-coverage"
		@@ -42,4 +44,7 @@ },
		"ts-jest": "^29.1.2",
		"typescript": "^5.4.3"
		"ts-loader": "^9.5.1",
		"typescript": "^5.4.3",
		"webpack": "^5.91.0",
		"webpack-cli": "^5.1.4"
		}
		}

+17

-0

README.md

-2

dist/index.js

		/* eslint-disable @typescript-eslint/no-unused-vars */
		export * from './libraries/ticker';

-1

dist/interfaces/ticker-options.interface.js

export {};

-44

dist/libraries/fps/fps.js

		export class Fps {
		_minFps;
		_currentFps = 60;
		_lastChecks = [];
		_calculateFpsEachMs = 2000;
		_msSinceLastCalculation = 0;
		_lowFpsInRow = 0;
		_lowFpsCallback;
		currentFps() {
		return this._currentFps;
		}
		calculate(msSinceLastTick) {
		this.collectFps(msSinceLastTick);
		this._msSinceLastCalculation += msSinceLastTick;
		if (this._msSinceLastCalculation >= this._calculateFpsEachMs) {
		this._msSinceLastCalculation = 0;
		this.calculateAverageFps();
		this.checkAndNotifyLowFps();
		}
		}
		onLowFps(minFps, callback) {
		this._minFps = minFps;
		this._lowFpsCallback = callback;
		}
		collectFps(msSinceLastTick) {
		this._lastChecks.push(Math.round(1000 / msSinceLastTick));
		}
		calculateAverageFps() {
		const sumFps = this._lastChecks.reduce((a, b) => a + b, 0);
		this._currentFps = Math.round(sumFps / this._lastChecks.length);
		this._lastChecks = [];
		}
		checkAndNotifyLowFps() {
		if (this._minFps && this._currentFps < this._minFps) {
		this._lowFpsInRow++;
		if (this._lowFpsInRow === 5) {
		this._lowFpsInRow = 0;
		if (this._lowFpsCallback) {
		this._lowFpsCallback();
		}
		}
		}
		}
		}

-53

dist/libraries/ticker.js

		import { Fps } from './fps/fps';
		import { DrawTicker } from './tickers/draw-ticker';
		import { LogicTicker } from './tickers/logic-ticker';
		export class Ticker {
		_fps = new Fps();
		_logicTicker;
		_drawTicker;
		constructor(options) {
		const minFps = options?.minFps \|\| 0;
		const maxFps = this.compensatedMaxFps(options?.maxFps \|\| 60);
		const expectedFps = options?.expectedFps \|\| 60;
		const onLogicTick = options?.onLogicTick;
		const onDrawTick = options?.onDrawTick;
		const onLowFps = options?.onLowFps;
		this._logicTicker = new LogicTicker(expectedFps);
		this._drawTicker = new DrawTicker(maxFps, expectedFps);
		if (onLogicTick) {
		this._logicTicker.onTick(onLogicTick);
		}
		if (onDrawTick) {
		this._drawTicker.onTick((msSinceLastTick) => {
		onDrawTick();
		this._fps.calculate(msSinceLastTick);
		});
		}
		if (onLowFps) {
		this._fps.onLowFps(minFps, onLowFps);
		}
		}
		start() {
		this._logicTicker.start();
		this._drawTicker.start();
		}
		stop() {
		this._logicTicker.stop();
		this._drawTicker.stop();
		}
		isStarted() {
		return this._logicTicker.isStarted() \|\| this._drawTicker.isStarted();
		}
		fps() {
		return this._fps.currentFps();
		}
		msBetweenTicks() {
		return this._logicTicker.isStarted() ? this._logicTicker.msBetweenTicks() : this._drawTicker.msBetweenTicks();
		}
		ticksMissed() {
		return this._logicTicker.isStarted() ? this._logicTicker.ticksMissed() : this._drawTicker.ticksMissed();
		}
		compensatedMaxFps(maxFps) {
		return Math.floor(maxFps * 1.1) + Math.floor(maxFps / 100) * 10;
		}
		}

-49

dist/libraries/tickers/draw-ticker.js

		export class DrawTicker {
		_maxMsBetweenTicks;
		_expectedMsBetweenTicks;
		_ticksMissed = 1;
		_msBetweenTicks = 0;
		_lastTickTime = 0;
		_requestFrameId;
		_tickCallback;
		constructor(maxFps, expectedFps) {
		this._maxMsBetweenTicks = 1000 / maxFps;
		this._expectedMsBetweenTicks = 1000 / expectedFps;
		}
		start() {
		if (this._tickCallback) {
		this._lastTickTime = performance.now();
		this.loop();
		}
		}
		stop() {
		if (this._requestFrameId) {
		window.cancelAnimationFrame(this._requestFrameId);
		this._requestFrameId = undefined;
		}
		}
		isStarted() {
		return !!this._requestFrameId;
		}
		onTick(callback) {
		this._tickCallback = callback;
		}
		msBetweenTicks() {
		return this._msBetweenTicks;
		}
		ticksMissed() {
		return this._ticksMissed;
		}
		loop() {
		const now = performance.now();
		this._msBetweenTicks = now - this._lastTickTime;
		this._ticksMissed = this._msBetweenTicks / this._expectedMsBetweenTicks;
		if (this._msBetweenTicks >= this._maxMsBetweenTicks) {
		this._lastTickTime = now;
		if (this._tickCallback) {
		this._tickCallback(this._msBetweenTicks);
		}
		}
		this._requestFrameId = window.requestAnimationFrame(this.loop.bind(this));
		}
		}

-48

dist/libraries/tickers/logic-ticker.js

		export class LogicTicker {
		_expectedMsBetweenTicks;
		_ticksMissed = 1;
		_msBetweenTicks = 0;
		_lastTickTime = 0;
		_timeoutId;
		_tickCallback;
		constructor(expectedFps) {
		this._expectedMsBetweenTicks = 1000 / expectedFps;
		}
		start() {
		if (this._tickCallback) {
		this._lastTickTime = performance.now();
		this.delayLoop();
		}
		}
		stop() {
		if (this._timeoutId) {
		clearTimeout(this._timeoutId);
		this._timeoutId = undefined;
		}
		}
		isStarted() {
		return !!this._timeoutId;
		}
		onTick(callback) {
		this._tickCallback = callback;
		}
		msBetweenTicks() {
		return this._msBetweenTicks;
		}
		ticksMissed() {
		return this._ticksMissed;
		}
		delayLoop() {
		this._timeoutId = setTimeout(() => this.loop(), this._expectedMsBetweenTicks);
		}
		loop() {
		const now = performance.now();
		this._msBetweenTicks = now - this._lastTickTime;
		this._ticksMissed = this._msBetweenTicks / this._expectedMsBetweenTicks;
		this._lastTickTime = now;
		if (this._tickCallback) {
		this._tickCallback(this._msBetweenTicks);
		}
		this.delayLoop();
		}
		}

New alerts