feat(throttle): add throttle utility function

src/utils/throttle.js

@@ -0,0 +1,35 @@
+export const createThrottleFn = () => {
+    return function (callback, limit) {
+        let blocked = false
+        let unblockTimeoutId = 0
+        let finalCallbackTimeoutId = 0
+
+        /**
+         * Calls the throttle function. Callbacks will be throttled according limit
+         * given to constructor function
+         * @returns 
+         */
+        function f() {
+            if (blocked) {
+                return
+            }
+
+            blocked = true
+            clearTimeout(finalCallbackTimeoutId)
+            callback.call()
+
+            unblockTimeoutId = setTimeout(() => { blocked = false }, limit)
+            finalCallbackTimeoutId = setTimeout(callback, limit + 5)
+        }
+
+        /**
+         * Clears internal timeouts and intervals to prevent further calls
+         */
+        f.clear = function () {
+            clearTimeout(unblockTimeoutId)
+            clearTimeout(finalCallbackTimeoutId)
+        }
+
+        return f
+    }
+}

tests/unit/utils/throttle.spec.js

@@ -0,0 +1,50 @@
+import { expect } from 'chai';
+import { createThrottleFn } from '../../../src/utils/throttle.js';
+
+describe('throttle', () => {
+
+    it('executes the first callback immediately', () => {
+        const throttle = createThrottleFn()
+        let throttledCallbacks = 0
+        throttle(() => {
+            throttledCallbacks++
+        }, 1000)()
+        expect(throttledCallbacks).to.equal(1)
+    })
+
+    it('executes the final callback after the elimit', async () => {
+        const throttle = createThrottleFn(100)
+        let throttledCallbacks = 0
+        throttle(() => {
+            throttledCallbacks++
+        }, 100)()
+        await new Promise((resolve) => setTimeout(resolve, 250))
+        expect(throttledCallbacks).to.equal(2)
+    })
+
+    it('does not execute the final if the timeouts were cleared', async () => {
+        const throttle = createThrottleFn(100)
+        let throttledCallbacks = 0
+        const fn = throttle(() => {
+            throttledCallbacks++
+        }, 100)
+        fn()
+        fn.clear()
+        await new Promise((resolve) => setTimeout(resolve, 250))
+        expect(throttledCallbacks).to.equal(1)
+    })
+
+    it('throttles callbacks according to given limit', async () => {
+        const throttle = createThrottleFn()
+        const fn = throttle(() => {
+            throttledCallbacks++
+        }, 500)
+        let throttledCallbacks = 0
+        for (let i = 0, n = 10; i < n; i++) {
+            fn()
+            await new Promise((resolve) => setTimeout(resolve, 30))
+        }
+        await new Promise((resolve) => setTimeout(resolve, 750))
+        expect(throttledCallbacks).to.equal(2)
+    })
+})