rewrites/parsers/parser-7.types.ts at main · zsakowitz/rewrites · 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
// Extra types for parser-7.

type ToArray<Length extends number, Accumulator extends any[] = []> =
    Accumulator["length"] extends Length ? Accumulator
    :   ToArray<Length, [...Accumulator, any]>

type ToNumber<T extends any[]> = number & T["length"]

type StringSlice<This extends string, Start extends any[]> =
    Start extends [any, ...infer StartTail extends any[]] ?
        string extends This ? string
        : This extends `${string}${infer StringTail}` ?
            StringSlice<StringTail, StartTail>
        :   ""
    :   This

type StringLength<This extends string, Total extends any[]> =
    string extends This ? number
    : This extends `${string}${infer Rest}` ?
        StringLength<Rest, [...Total, any]>
    :   ToNumber<Total>

declare global {
    interface String {
        startsWith<
            This extends string,
            Text extends string,
            Position extends number = 0,
        >(
            this: This,
            text: Text,
            position?: Position,
        ): StringSlice<This, ToArray<Position>> extends `${Text}${string}` ?
            true
        :   false
    }

    namespace String {
        type startsWith<
            This extends string,
            Text extends string,
            Position extends number = 0,
        > =
            string extends This ? boolean
            : StringSlice<This, ToArray<Position>> extends `${Text}${string}` ?
                true
            :   false

        type length<This extends string> = StringLength<This, []>

        type charAt<This extends string, Position extends number> =
            string extends This ? string
            : StringSlice<This, ToArray<Position>> extends (
                `${infer Character}${string}`
            ) ?
                Character
            :   ""
    }

    namespace Number {
        type add<A extends number, B extends number> =
            number extends A ? number
            : number extends B ? number
            : ToNumber<[...ToArray<A>, ...ToArray<B>]>

        type plusOne<N extends number> =
            number extends N ? number : ToNumber<[...ToArray<N>, any]>
    }
}

export {}