fix: forward generics to the generated types when transforming a `Typ…

…eLiteral`

[converter]

=== changelog ===
```ts
export type Callback<Param, AtomType> = (event: {
    atom: AtomType;
}) => void;
```

```fs
[<AllowNullLiteral>]
[<Interface>]
type Callback<'Param, 'AtomType> =
    [<Emit("$0($1...)")>]
    abstract member Invoke: event: Callback.event<'AtomType> -> unit

module Callback =

    [<Global>]
    [<AllowNullLiteral>]
    type event<'AtomType>
        [<ParamObject; Emit("$0")>]
        (
            atom: 'AtomType
        ) =

        member val atom : 'AtomType = nativeOnly with get, set
```

Fix #148

src/Glutinum.Converter/Transform.fs

@@ -686,6 +686,23 @@ let rec private transformType (context: TransformContext) (glueType: GlueType) :
                 | GlueMember.ConstructSignature _ -> true
             )
 
+        let typeParameterNames =
+            typeLiteralInfo.Members
+            |> List.choose (fun m ->
+                match m with
+                | GlueMember.MethodSignature { Type = typ }
+                | GlueMember.Method { Type = typ }
+                | GlueMember.Property { Type = typ }
+                | GlueMember.GetAccessor { Type = typ }
+                | GlueMember.SetAccessor { ArgumentType = typ }
+                | GlueMember.CallSignature { Type = typ }
+                | GlueMember.IndexSignature { Type = typ }
+                | GlueMember.ConstructSignature { Type = typ } ->
+                    match typ with
+                    | GlueType.TypeParameter name -> Some name
+                    | _ -> None
+            )
+
         if hasNoIndexSignature then
 
             let typeLiteralParameters =
@@ -720,6 +737,19 @@ let rec private transformType (context: TransformContext) (glueType: GlueType) :
                     : FSharpExplicitField
                 )
 
+            let typeParameters =
+                typeParameterNames
+                |> List.map (fun name ->
+                    ({
+                        Name = name
+                        Constraint = None
+                        Default = None
+                    }
+                    : FSharpTypeParameterInfo)
+                    |> FSharpTypeParameter.FSharpTypeParameter
+
+                )
+
             ({
                 Attributes = [ FSharpAttribute.Global; FSharpAttribute.AllowNullLiteral ]
                 Name = context.CurrentScopeName
@@ -731,7 +761,7 @@ let rec private transformType (context: TransformContext) (glueType: GlueType) :
                     }
                 SecondaryConstructors = []
                 ExplicitFields = explicitFields
-                TypeParameters = []
+                TypeParameters = typeParameters
             }
             : FSharpClass)
             |> FSharpType.Class
@@ -759,7 +789,16 @@ let rec private transformType (context: TransformContext) (glueType: GlueType) :
         ({
             Name = context.FullName
             FullName = context.FullName
-            TypeArguments = []
+            TypeArguments =
+                typeParameterNames
+                |> List.map (fun name ->
+                    ({
+                        Name = $"'%s{name}"
+                        TypeParameters = []
+                    }
+                    : FSharpMapped)
+                    |> FSharpType.Mapped
+                )
             Type = FSharpType.Discard
         }
         : FSharpTypeReference)

tests/specs/references/typeLiteral/functionType/generics.d.ts

@@ -0,0 +1,5 @@
+export type Callback<Param, AtomType> = (event: {
+    type: 'CREATE' | 'REMOVE';
+    param: Param;
+    atom: AtomType;
+}) => void;

tests/specs/references/typeLiteral/functionType/generics.fsx

@@ -0,0 +1,40 @@
+module rec Glutinum
+
+open Fable.Core
+open Fable.Core.JsInterop
+open System
+
+[<AllowNullLiteral>]
+[<Interface>]
+type Callback<'Param, 'AtomType> =
+    [<Emit("$0($1...)")>]
+    abstract member Invoke: event: Callback.event<'Param, 'AtomType> -> unit
+
+module Callback =
+
+    [<Global>]
+    [<AllowNullLiteral>]
+    type event<'Param, 'AtomType>
+        [<ParamObject; Emit("$0")>]
+        (
+            ``type``: Callback.event.``type``,
+            param: 'Param,
+            atom: 'AtomType
+        ) =
+
+        member val ``type`` : Callback.event.``type`` = nativeOnly with get, set
+        member val param : 'Param = nativeOnly with get, set
+        member val atom : 'AtomType = nativeOnly with get, set
+
+    module event =
+
+        [<RequireQualifiedAccess>]
+        [<StringEnum(CaseRules.None)>]
+        type ``type`` =
+            | CREATE
+            | REMOVE
+
+(***)
+#r "nuget: Fable.Core"
+#r "nuget: Glutinum.Types"
+(***)