Rework TypeAlias definition and better handled literal unions

src/Glutinum.Converter/GlueAST.fs

@@ -106,7 +106,7 @@ type GlueEnum =
 type GlueTypeAliasDeclaration =
     {
         Name: string
-        Types: GlueType list
+        Type: GlueType
     }
 
 type GlueFunctionDeclaration =

src/Glutinum.Converter/Read.fs

@@ -246,17 +246,21 @@ let rec private readUnionTypeCases
                 |> GlueType.TypeReference
                 |> List.singleton
                 |> Some
-
             else
-                symbol.declarations
-                |> Seq.toList
-                |> List.collect (fun declaration ->
-                    // We use the readUnionType to handle nested unions
-                    let enum = readUnionType checker declaration?``type``
+                let declaration = symbol.declarations.[0]
 
-                    [ enum ]
-                )
-                |> Some
+                readNode checker declaration |> List.singleton |> Some
+
+        // else
+        //     symbol.declarations
+        //     |> Seq.toList
+        //     |> List.collect (fun declaration ->
+        //         // We use the readUnionType to handle nested unions
+        //         let enum = readUnionType checker declaration?``type``
+
+        //         [ enum ]
+        //     )
+        //     |> Some
         else
             match node.kind with
             | Ts.SyntaxKind.UnionType ->
@@ -336,7 +340,7 @@ let private readTypeAliasDeclaration
     : GlueType
     =
 
-    let types =
+    let typ =
         match declaration.``type``.kind with
         | Ts.SyntaxKind.UnionType ->
             let unionTypeNode = declaration.``type`` :?> Ts.UnionTypeNode
@@ -355,7 +359,7 @@ let private readTypeAliasDeclaration
 
     {
         Name = declaration.name.getText ()
-        Types = [ types ]
+        Type = typ
     }
     |> GlueType.TypeAliasDeclaration
 
@@ -452,18 +456,18 @@ let private tryReadVariableStatement
         let declaration =
             statement.declarationList.declarations |> Seq.toList |> List.head
 
-
         let name =
             match declaration.name?kind with
             | Ts.SyntaxKind.Identifier ->
                 let id: Ts.Identifier = !!declaration.name
                 id.getText ()
             | _ -> failwith "readVariableStatement: Unsupported kind"
 
-        {
+        ({
             Name = name
             Type = readTypeNode checker declaration.``type``
         }
+        : GlueVariable)
         |> Some
     else
         None

src/Glutinum.Converter/Transform.fs

@@ -401,31 +401,51 @@ let private transformTypeAliasDeclaration
     =
 
     // TODO: Make the transformation more robust
-    match glueTypeAliasDeclaration.Types with
-    | GlueType.Union cases :: [] ->
+    match glueTypeAliasDeclaration.Type with
+    | GlueType.Union cases ->
+        printfn "%A" cases
+
+        // let
         // Unions can have nested unions, so we need to flatten them
         // TODO: Is there cases where we don't want to flatten?
         // U2<U2<int, string>, bool>
         let rec flattenCases (cases: GlueType list) : GlueType list =
             cases
             |> List.collect (
                 function
+                // We are inside an union, and have access to the literal types
+                | GlueType.Literal _ as literal -> [ literal ]
                 | GlueType.Union cases -> flattenCases cases
-                | glueType -> [ glueType ]
+                | GlueType.TypeAliasDeclaration aliasCases ->
+                    match aliasCases.Type with
+                    | GlueType.Union cases -> flattenCases cases
+                    | _ -> failwith "Should not happen"
+                // Can't find cases so we return an empty list to discard the type
+                // Should we do something if we fall in this state?
+                // I think the code below will be able to recover by generating
+                // an erased enum, but I don't know if there cases where we could
+                // be bitting ourselves in the foot
+                | _ -> []
             )
 
-        let cases = flattenCases cases
+        let flattenedCases = flattenCases cases
 
         let isStringOnly =
-            cases
-            |> List.forall (
-                function
-                | GlueType.Literal(GlueLiteral.String _) -> true
-                | _ -> false
-            )
+            // If the list is empty, it means that there was no candidates
+            // for string literals
+            not flattenedCases.IsEmpty
+            && flattenedCases
+               |> List.forall (
+                   function
+                   | GlueType.Literal(GlueLiteral.String _) -> true
+                   | _ -> false
+               )
 
         let isNumericOnly =
-            cases
+            // If the list is empty, it means that there was no candidates
+            // for numeric literals
+            not flattenedCases.IsEmpty
+            && flattenedCases
             |> List.forall (
                 function
                 | GlueType.Literal(GlueLiteral.Int _) -> true
@@ -436,7 +456,7 @@ let private transformTypeAliasDeclaration
         // we can transform it into a StringEnum
         if isStringOnly then
             let cases =
-                cases
+                flattenedCases
                 |> List.map (fun value ->
                     match value with
                     | GlueType.Literal(GlueLiteral.String value) ->
@@ -470,7 +490,7 @@ let private transformTypeAliasDeclaration
         // we can transform it into a standard F# enum
         else if isNumericOnly then
             let cases =
-                cases
+                flattenedCases
                 |> List.map (fun value ->
                     match value with
                     | GlueType.Literal(GlueLiteral.Int value) ->
@@ -499,12 +519,12 @@ let private transformTypeAliasDeclaration
             : FSharpTypeAlias)
             |> FSharpType.Alias
 
-    | GlueType.KeyOf glueType :: [] ->
+    | GlueType.KeyOf glueType ->
         TypeAliasDeclaration.transformKeyOf
             glueTypeAliasDeclaration.Name
             glueType
 
-    | GlueType.IndexedAccessType glueType :: [] ->
+    | GlueType.IndexedAccessType glueType ->
         let typ =
             match glueType with
             | GlueType.KeyOf glueType ->
@@ -537,23 +557,23 @@ let private transformTypeAliasDeclaration
         : FSharpTypeAlias)
         |> FSharpType.Alias
 
-    | GlueType.Primitive primitiveInfo :: [] ->
+    | GlueType.Primitive primitiveInfo ->
         ({
             Name = glueTypeAliasDeclaration.Name
             Type = transformPrimitive primitiveInfo |> FSharpType.Primitive
         }
         : FSharpTypeAlias)
         |> FSharpType.Alias
 
-    | GlueType.TypeReference typeReference :: [] ->
+    | GlueType.TypeReference typeReference ->
         ({
             Name = glueTypeAliasDeclaration.Name
             Type = transformType (GlueType.TypeReference typeReference)
         }
         : FSharpTypeAlias)
         |> FSharpType.Alias
 
-    | GlueType.Array glueType :: [] ->
+    | GlueType.Array glueType ->
         ({
             Name = glueTypeAliasDeclaration.Name
             Type = transformType (GlueType.Array glueType)

tests/libs/dayjs.d.ts

@@ -20,6 +20,6 @@ declare namespace dayjs {
 
   export interface FormatObject { locale?: string, format?: string, utc?: boolean }
 
-  export type OptionType = string | string[]
+  export type OptionType = FormatObject | string | string[]
 
 }

tests/specs/enums/literalNumericEnumWithNestedEnums.d.ts

@@ -0,0 +1,12 @@
+export type NumberA =
+	| 1
+
+export type NumberB =
+	| 2
+
+export type NumberC = NumberA | NumberB;
+
+export type NumberD =
+    | 3
+
+export type NumberE = NumberC | NumberD;

tests/specs/enums/literalNumericEnumWithNestedEnums.fsx

@@ -0,0 +1,31 @@
+module rec Glutinum
+
+(***)
+#r "nuget: Fable.Core"
+(***)
+
+open Fable.Core
+open System
+
+[<RequireQualifiedAccess>]
+type NumberA =
+    | ``1`` = 1
+
+[<RequireQualifiedAccess>]
+type NumberB =
+    | ``2`` = 2
+
+[<RequireQualifiedAccess>]
+type NumberC =
+    | ``1`` = 1
+    | ``2`` = 2
+
+[<RequireQualifiedAccess>]
+type NumberD =
+    | ``3`` = 3
+
+[<RequireQualifiedAccess>]
+type NumberE =
+    | ``1`` = 1
+    | ``2`` = 2
+    | ``3`` = 3

tests/specs/typeAlias/unions/primitiveAndTypeReferenceToAnInterface.d.ts

@@ -0,0 +1,3 @@
+export interface FormatObject { locale?: string, format?: string, utc?: boolean }
+
+export type OptionType = FormatObject | string | string[]

tests/specs/typeAlias/unions/primitiveAndTypeReferenceToAnInterface.fsx

@@ -0,0 +1,17 @@
+module rec Glutinum
+
+(***)
+#r "nuget: Fable.Core"
+(***)
+
+open Fable.Core
+open System
+
+[<AllowNullLiteral>]
+type FormatObject =
+    abstract member locale: string with get, set
+    abstract member format: string with get, set
+    abstract member utc: bool with get, set
+
+type OptionType =
+    U3<FormatObject, string, ResizeArray<string>>