bool/is.ts at main · Antman261/bool · GitHub

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
import { isFalse } from './false.ts';

/**
 * A wrapper containing a value to compare with parameters provided in subsequent operations
 */
export type IsBox<T extends unknown> = {
  /**
   * Check the wrapped value is less than the parameter. Throws if the wrapped value is not a number or bigint
   */
  lessThan<Y extends number | bigint>(y: Y): boolean;
  /**
   * Check the wrapped value is greater than the parameter. Throws if the wrapped value is not a number or bigint
   */
  greaterThan<Y extends number | bigint>(y: Y): boolean;
  /**
   * Check the wrapped value strictly equals the parameter
   */
  eq(y: T): boolean;
  /**
   * Check the wrapped value loosely equals the parameter
   */
  looseEq(y: T): boolean;
  /**
   * Invert the checks
   */
  not: {
    /**
     * Check the wrapped value is NOT less than the parameter. Throws if the wrapped value is not a number or bigint
     */
    lessThan<Y extends number | bigint>(y: Y): boolean;
    /**
     * Check the wrapped value is NOT greater than the parameter. Throws if the wrapped value is not a number or bigint
     */
    greaterThan<Y extends number | bigint>(y: Y): boolean;
    /**
     * Check the wrapped value does NOT strictly equal the parameter
     */
    eq(y: T): boolean;
    /**
     * Check the wrapped value does not loosely equal the parameter
     */
    looseEq(y: T): boolean;
  };
};

/**
 * Wrap a value in a shallow fluent interface for boolean checks.
 *
 * Use `is` to improve readability, for example:
 *
 * ```
 * const isFoo = is(foo)
 * if (isFoo.lessThan(bar)) doSomething(foo);
 * if (isFoo.not.eq(bar)) doSomethingElse(foo);t
 * ```
 */
export function is<T extends unknown>(x: T): IsBox<T> {
  return {
    lessThan: (y) => {
      if (typeof x !== 'number' && typeof x !== 'bigint') {
        throw new TypeError('Cannot less-than compare non-numeric type');
      }
      return x < y;
    },
    greaterThan: (y) => {
      if (typeof x !== 'number' && typeof x !== 'bigint') {
        throw new TypeError('Cannot greater-than compare non-numeric type');
      }
      return x > y;
    },
    eq: (y) => x === y,
    looseEq: (y) => x == y,
    not: {
      lessThan: (y) => {
        if (typeof x !== 'number' && typeof x !== 'bigint') {
          throw new TypeError('Cannot less-than compare non-numeric type');
        }
        return isFalse(x < y);
      },
      greaterThan: (y) => {
        if (typeof x !== 'number' && typeof x !== 'bigint') {
          throw new TypeError('Cannot greater-than compare non-numeric type');
        }
        return isFalse(x > y);
      },
      eq: (y) => x !== y,
      looseEq: (y) => x != y,
    },
  };
}