		const timerPro = {
		timers: {
		Timeout: {},
		Interval: {},
		},
		timerAll: function() {
		return timerPro.timers;
		},
		timerExist: function(type, name) {
		return (timerPro.timers[type] && timerPro.timers[type][name]);
		},
		isArray: function(array) {
		return Array.isArray(array);
		},
		new: {
		newTimer: function(type, name, timer) {
		if(!timerPro.timerExist(type, name)) timerPro.timers[type][name] = [];
		timerPro.timers[type][name].push(timer);
		},
		timeout: function(name, func, delay, args = [], reset = false) {
		if(!timerPro.isArray(args)) args = [];
		if(reset) timerPro.reset.timeout();
		timerPro.new.newTimer("Timeout", name, setTimeout(func, delay, ...args));
		},
		interval: function(name, func, delay, args = [], reset = false) {
		if(!timerPro.isArray(args)) args = [];
		if(reset) timerPro.reset.interval();
		timerPro.new.newTimer("Interval", name, setTimeout(func, delay, ...args));
		}
		},
		clear: {
		doClear: function(type, name) {
		if(!timerPro.timerExist(type, name)) return;
		for(timer of timerPro.timers[type][name])
		{
		if(type == "Timeout") clearTimeout(timer);
		if(type == "Interval") clearInterval(timer);
		}

		timerPro.timers[type][name] = [];
		},
		timeout: function(name) {
		timerPro.clear.doClear("Timeout", name);
		},
		interval: function(name) {
		timerPro.clear.doClear("Interval", name);
		},
		timer(type) {
		for(name in timerPro.timers[type]) timerPro.clear.doClear(type, name);
		},
		all() {
		timerPro.clear.timer("Timeout");
		timerPro.clear.timer("Interval");
		}
		},
		clean: {
		doClean: function(type, name) {
		if(!timerPro.timerExist(type, name)) return;
		let timer, new_list = [];
		for(id in timerPro.timers[type][name])
		{
		timer = timerPro.timers[type][name][id];
		if(timer && !timer._destroyed) {
		new_list.push(timer);
		}
		}

		timerPro.timers[type][name] = new_list;
		},
		timeout: function(name) {
		timerPro.clean.doClean("Timeout", name);
		},
		interval: function(name) {
		timerPro.clean.doClean("Interval", name);
		},
		timer: function(type) {
		for(name in timerPro.timers[type]) timerPro.clean.doClean(type, name);
		},
		all: function() {
		timerPro.clean.timer("Timeout");
		timerPro.clean.timer("Interval");
		}
		},
		reset: {
		timeout: function(name) {
		timerPro.clear.timeout(name);
		timerPro.clean.timeout(name);
		},
		interval: function(name) {
		timerPro.clear.interval(name);
		timerPro.clean.interval(name);
		}
		}
		}

		if (typeof module !== 'undefined') {
		module.exports = timerPro;
		}

+1

dist/timerpro.min.js

+2

-2

package.json

		{
		"name": "timerpro",
		"version": "1.0.1",
		"version": "1.0.2",
		"description": "Manage intervals and timeouts like a pro",
		"main": "index.js",
		"main": "dist/timerpro.js",
		"scripts": {
		@@ -7,0 +7,0 @@ "test": "echo \"Error: no test specified\" && exit 1"

+54

-101

README.md

		@@ -7,119 +7,72 @@ Since intervals and timeouts lists are not saved on the browser. This package helps you to manage them.

		### NodeJs
		```plaintext
		const timerPro = require("timerpro");
		```

		## Methods:

		Create new timeout (setTimeout)

		### Browser:
		```plaintext
		new_timeout(timerName, timerFN, timerDelay, timerArgs);

		Example:
		timerPro.new_timeout("MyRefresh", (msg) => {
		console.log(msg);
		}, 500, "Hello world!);
		<script src="https://cdn.jsdelivr.net/npm/timerpro/dist/timerpro.min.js"></script>
		```

		Create new interval (setInterval)
		## Methods:
		### Create new timeout (setTimeout)
		- name: Timeout name
		- func: Code to run
		- delay: Run code after ms
		- args: Array of arguments to pass inside the func
		- reset: Auto reset before next run

		```plaintext
		new_interval(timerName, timerFN, timerDelay, timerArgs);

		Example:
		timerPro.new_interval("MyRefresh", (msg) => {
		console.log(msg);
		}, 500, "Hello world!);
		```javascript
		timerPro.new.timeout(name, func, delay, args = [], reset = false);
		```

		Get last timeout or interval ID

		```plaintext
		get_last_timeout_id(timerName);
		get_last_interval_id(timerName);

		Example:
		get_last_timeout_id("MyRefresh");
		get_last_interval_id("MyRefresh");
		### Example:
		```javascript
		timerPro.new.timeout("MyTimeout", (i, msg) => {
		console.log(`${i} - ${msg}`);
		}, 5000, [1, "Hello World !"]);
		```

		Get timeout or interval by ID

		```plaintext
		get_timeout_by_id(timerName, id);
		get_interval_by_id(timerName, id);

		Example:
		get_timeout_by_id("MyRefresh", 1);
		get_interval_by_id("MyRefresh", 1);
		### Create new interval (setInterval)
		- name: Interval name
		- func: Code to run
		- delay: Run code after ms
		- args: Array of arguments to pass inside the func
		- reset: Auto reset before next run
		```javascript
		timerPro.new.interval(name, func, delay, args = [], reset = false);
		```

		Clear timeout or interval by ID

		```plaintext
		clear_timeout_by_id(timerName, id);
		clear_interval_by_id(timerName, id);

		Example:
		clear_timeout_by_id("MyRefresh", 1);
		clear_interval_by_id("MyRefresh", 1);
		### Example:
		```javascript
		timerPro.new.interval("MyInterval", (i, msg) => {
		console.log(`${i} - ${msg}`);
		}, 5000, [1, "Hello World !"]);
		```

		Clear all the timeouts or intervals by name

		```plaintext
		clear_timeouts(timerName);
		clear_intervals(timerName);

		Example:
		clear_timeouts("MyRefresh");
		clear_intervals("MyRefresh");
		### Get all timers
		Get all the timers (timeout and interval) in a Object.
		```javascript
		timerPro.timerAll();
		```

		Clear all the timeouts or intervals

		```plaintext
		clear_all_timeouts();
		clear_all_intervals();

		Example:
		clear_all_timeouts();
		clear_all_intervals();
		### Example:
		```javascript
		console.log(timerPro.timerAll());
		```

		Clear all the timeouts and intervals ever created

		```plaintext
		clear_all();

		Example:
		clear_all();
		### Clear timers
		Clear timers by name. Use all to clear all the timers.
		```javascript
		timerPro.clear.timeout(name)
		timerPro.clear.interval(name)
		timerPro.clear.all()
		```

		Get all the timeouts and intervals ever created

		```plaintext
		get_all();

		Example:
		console.log(get_all());
		### Clean timers
		Clean and reorder finished timers by name. Use all to clean and reorder all the timers.
		```javascript
		timerPro.clean.timeout(name)
		timerPro.clean.interval(name)
		timerPro.clean.all()
		```

		Clean and reorder finished and deleted timeouts or intervals

		```plaintext
		clean(type) // "Timeout", "Interval"

		Example:
		clean("Timeout");
		```

		Clean and reorder finished and deleted timeouts and intervals

		```plaintext
		clean_all();

		Example:
		clean_all();
		### Reset timers
		Automatically clear and clean the timers.
		```javascript
		timerPro.reset.timeout(name)
		timerPro.reset.interval(name)
		```

-220

index.js

		var TimerProParent = {
		'Timeout' : {},
		'Interval' : {}
		};

		const timer_exist = (type, timerName) => {
		if(TimerProParent[type] && TimerProParent[type][timerName])
		{
		return true;
		}

		return false;
		};

		const get_last_id = (type, timerName) => {
		if(timer_exist(type, timerName) === false)
		{
		return false;
		}

		return TimerProParent[type][timerName].length - 1;
		};

		const get_by_id = (type, timerName, id) => {
		if(timer_exist(type, timerName) === false)
		{
		return false;
		}

		if(!TimerProParent[type][timerName][id])
		{
		return false;
		}

		return TimerProParent[type][timerName][id];
		};

		const clear_by_id = (type, timerName, id) => {
		if(timer_exist(type, timerName) === false)
		{
		return false;
		}

		if(!TimerProParent[type][timerName][id])
		{
		return false;
		}

		if(type == "Timeout")
		{
		clearTimeout(TimerProParent[type][timerName][id]);
		}

		if(type == "Interval")
		{
		clearInterval(TimerProParent[type][timerName][id]);

		}

		TimerProParent[type][timerName][id] = null;
		return true;
		};

		const new_timer = (type, timerName, timerFN) => {
		if(timer_exist(type, timerName) === false)
		{
		TimerProParent[type][timerName] = [];
		}

		TimerProParent[type][timerName].push(timerFN);
		return get_last_id(type, timerName);
		};

		const clear_timer = (type, timerName) => {
		if(timer_exist(type, timerName) === false)
		{
		return true;
		}

		for(timer of TimerProParent[type][timerName])
		{
		if(type == "Timeout")
		{
		clearTimeout(timer);
		}

		if(type == "Interval")
		{
		clearInterval(timer);
		}
		}

		TimerProParent[type][timerName] = [];
		return true;
		};

		const clean_timer = (type, timerName) => {
		if(timer_exist(type, timerName) === false)
		{
		return true;
		}

		let timer, new_list = [];
		for(id in TimerProParent[type][timerName])
		{
		timer = TimerProParent[type][timerName][id];
		if(timer && !timer._destroyed) {
		new_list.push(timer);
		}
		}

		TimerProParent[type][timerName] = new_list;
		return true;
		};

		const clean = (type) => {
		for(timerName in TimerProParent[type])
		{
		clean_timer(type, timerName);
		}
		return true;
		};

		const new_timeout = (timerName, timerFN, timerDelay, timerArgs = []) => {
		if(typeof timerArgs != "object") timerArgs = [];
		let timeout = setTimeout(timerFN, timerDelay, ...timerArgs);
		return new_timer("Timeout", timerName, timeout);
		};

		const new_interval = (timerName, timerFN, timerDelay, timerArgs = []) => {
		if(typeof timerArgs != "object") timerArgs = [];
		let interval = setInterval(timerFN, timerDelay, ...timerArgs);
		return new_timer("Interval", timerName, interval);
		};

		const get_last_timeout_id = (timerName) => {
		return get_last_id("Timeout", timerName);
		};

		const get_last_interval_id = (timerName) => {
		return get_last_id("Interval", timerName);
		};

		const get_timeout_by_id = (timerName, id) => {
		return get_by_id("Timeout", timerName, id);
		};

		const get_interval_by_id = (timerName, id) => {
		return get_by_id("Interval", timerName, id);
		};

		const clear_timeout_by_id = (timerName, id) => {
		return clear_by_id("Timeout", timerName, id);
		};

		const clear_interval_by_id = (timerName, id) => {
		return clear_by_id("Interval", timerName, id);
		};

		const clear_timeouts = (timerName) => {
		return clear_timer("Timeout", timerName);
		};

		const clear_intervals = (timerName) => {
		return clear_timer("Interval", timerName);
		};

		const clear_all_timeouts = () => {
		for(timerName in TimerProParent["Timeout"])
		{
		clear_timer("Timeout", timerName);
		}

		return true;
		};

		const clear_all_intervals = () => {

		for(timerName in TimerProParent["Interval"])
		{
		clear_timer("Interval", timerName);
		}

		return true;
		};

		const clear_all = () => {
		clear_all_timeouts();
		clear_all_intervals();
		return true;
		};

		const get_all = () => {
		return TimerProParent;
		};

		const clean_all = () => {
		clean("Timeout");
		clean("Interval");
		return true;
		};

		module.exports = {
		new_timeout,
		new_interval,
		get_last_timeout_id,
		get_last_interval_id,
		get_timeout_by_id,
		get_interval_by_id,
		clear_timeout_by_id,
		clear_interval_by_id,
		clear_timeouts,
		clear_intervals,
		clear_all_timeouts,
		clear_all_intervals,
		clear_all,
		get_all,
		clean_all,
		clean
		};

timerpro - npm Package Compare versions

New alerts

Improved metrics

Worsened metrics