274 - Integers Comparator - any numbers

[teamchong]

enum Comparison {
  Greater,
  Equal,
  Lower,
}

type Comparator<X extends number, Y extends number> = {'<': Comparison.Lower, '=': Comparison.Equal, '>': Comparison.Greater}[CompareNumbers<`${X}`, `${Y}`>]

// Type to compare two numeric types X and Y and determine their relational order as '<', '=', or '>'.
type CompareNumbers<X extends string, Y extends string>
  = `${X}${Y}` extends `-${infer A}-${infer B}` ? CompareNumbers<B, A> // Handles comparison when both numbers are negative, invert the comparison order to compare their positive counterparts
  : X extends `-${any}` ? '<' // If X is negative and Y is not Y is greater
  : Y extends `-${any}` ? '>' // If Y is negative and X is not X is greater
  : `${X} ${Y}` extends `${infer A}e+${infer E} ${infer B}e+${infer F}` ? CompareInteger<E, F> extends '=' ? CompareNumbers<A, B> : CompareInteger<E, F>
  : X extends `${any}e+${any}` ? '>'
  : Y extends `${any}e+${any}` ? '<'
  : `${X} ${Y}` extends `${infer A}e-${infer E} ${infer B}e-${infer F}` ? CompareInteger<F, E> extends '=' ? CompareNumbers<A, B> : CompareInteger<F, E>
  : X extends `${any}e-${any}` ? '<'
  : Y extends `${any}e-${any}` ? '>'
  : `${X} ${Y}` extends `${infer A}.${infer C} ${infer B}.${infer D}` ? CompareInteger<A, B> extends '=' ? CompareFractional<C, D> : CompareInteger<A, B>
  : X extends `${infer A}.${any}` ? CompareInteger<A, Y> extends '=' ? '>' : CompareInteger<A, Y>
  : Y extends `${infer B}.${any}` ? CompareInteger<X, B> extends '=' ? '<' : CompareInteger<X, B>
  : CompareInteger<X, Y>

// Recursive type to compare integer strings and determine their order.
type CompareInteger<X extends string, Y extends string, PreviousComparison extends '<' | '=' | '>' = '='>
  = X extends Y ? PreviousComparison // If both strings are equal, return the previous comparison result
  : `${X} ${Y}` extends `${infer A}${infer C} ${infer B}${infer D}`
    ? CompareInteger<C, D,
        PreviousComparison extends '<' | '>' ? PreviousComparison // If difference has been found, Carry forward the first difference
        : A extends B ? '=' // If current digits are the same, skip to next
        : '0123456789' extends `${any}${A}${any}${B}${any}` ? '<' : '>'> // Compare digits lexicographically
  : X extends '' ? '<' : '>' // longer is greater

type CompareFractional<X extends string, Y extends string>
  = `${X} ${Y}` extends `${infer A}${infer C} ${infer B}${infer D}`
    ? A extends B ? CompareFractional<C, D> // If current digits are the same, skip to next
    : '0123456789' extends `${any}${A}${any}${B}${any}` ? '<' : '>' // Compare digits lexicographically
  : X extends '' ? '<' : '>' // longer is greater

Playground