File size: 2,867 Bytes
1e92f2d
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
import { useMemo } from 'react';
import useGetSet from './useGetSet';
import { IHookStateInitAction, IHookStateSetAction, resolveHookState } from './misc/hookState';

export interface CounterActions {
  inc: (delta?: number) => void;
  dec: (delta?: number) => void;
  get: () => number;
  set: (value: IHookStateSetAction<number>) => void;
  reset: (value?: IHookStateSetAction<number>) => void;
}

export default function useCounter(
  initialValue: IHookStateInitAction<number> = 0,
  max: number | null = null,
  min: number | null = null
): [number, CounterActions] {
  let init = resolveHookState(initialValue);

  typeof init !== 'number' &&
    console.error('initialValue has to be a number, got ' + typeof initialValue);

  if (typeof min === 'number') {
    init = Math.max(init, min);
  } else if (min !== null) {
    console.error('min has to be a number, got ' + typeof min);
  }

  if (typeof max === 'number') {
    init = Math.min(init, max);
  } else if (max !== null) {
    console.error('max has to be a number, got ' + typeof max);
  }

  const [get, setInternal] = useGetSet(init);

  return [
    get(),
    useMemo(() => {
      const set = (newState: IHookStateSetAction<number>) => {
        const prevState = get();
        let rState = resolveHookState(newState, prevState);

        if (prevState !== rState) {
          if (typeof min === 'number') {
            rState = Math.max(rState, min);
          }
          if (typeof max === 'number') {
            rState = Math.min(rState, max);
          }

          prevState !== rState && setInternal(rState);
        }
      };

      return {
        get,
        set,
        inc: (delta: IHookStateSetAction<number> = 1) => {
          const rDelta = resolveHookState(delta, get());

          if (typeof rDelta !== 'number') {
            console.error(
              'delta has to be a number or function returning a number, got ' + typeof rDelta
            );
          }

          set((num: number) => num + rDelta);
        },
        dec: (delta: IHookStateSetAction<number> = 1) => {
          const rDelta = resolveHookState(delta, get());

          if (typeof rDelta !== 'number') {
            console.error(
              'delta has to be a number or function returning a number, got ' + typeof rDelta
            );
          }

          set((num: number) => num - rDelta);
        },
        reset: (value: IHookStateSetAction<number> = init) => {
          const rValue = resolveHookState(value, get());

          if (typeof rValue !== 'number') {
            console.error(
              'value has to be a number or function returning a number, got ' + typeof rValue
            );
          }

          // eslint-disable-next-line react-hooks/exhaustive-deps
          init = rValue;
          set(rValue);
        },
      };
    }, [init, min, max]),
  ];
}