RocketChat/Rocket.Chat

export const withThrottling =
    ({ wait, leading, trailing }: { wait: number; leading?: boolean; trailing?: boolean }) =>
    <TFunction extends (...args: any[]) => any>(fn: TFunction) => {
        let timer: ReturnType<typeof setTimeout> | undefined = undefined;
        let result: ReturnType<TFunction>;
        let previous = 0;

        function throttled(this: ThisParameterType<TFunction>, ...args: Parameters<TFunction>) {
            const now = Date.now();
            if (!previous && leading === false) previous = now;
            const remaining = wait - (now - previous);

            if (remaining <= 0 || remaining > wait) {
                if (timer) clearTimeout(timer);
                timer = undefined;
                previous = now;
                result = fn.apply(this, args);
            } else if (!timer && trailing !== false) {
                const later = () => {
                    previous = leading === false ? 0 : Date.now();
                    result = fn.apply(this, args);
                    timer = undefined;
                };
                timer = setTimeout(later, remaining);
            }
            return result;
        }

        const cancel = () => {
            if (timer) clearTimeout(timer);
            previous = 0;
            timer = undefined;
        };

        return Object.assign(throttled, { cancel });
    };

export const withDebouncing =
    ({ wait, immediate }: { wait: number; immediate?: boolean }) =>
    <TFunction extends (...args: any[]) => any>(fn: TFunction) => {
        let timer: ReturnType<typeof setTimeout> | undefined = undefined;
        let result: ReturnType<TFunction>;
        let previous: number;

        function debounced(this: ThisParameterType<TFunction>, ...args: Parameters<TFunction>) {
            previous = Date.now();
            if (!timer) {
                const later = () => {
                    const passed = Date.now() - previous;
                    if (wait > passed) {
                        timer = setTimeout(later, wait - passed);
                    } else {
                        timer = undefined;
                        if (!immediate) result = fn.apply(this, args);
                    }
                };
                timer = setTimeout(later, wait);
                if (immediate) result = fn.apply(this, args);
            }
            return result;
        }

        const cancel = () => {
            clearTimeout(timer);
            timer = undefined;
        };

        return Object.assign(debounced, { cancel });
    };