-
Notifications
You must be signed in to change notification settings - Fork 1
/
ts.go
92 lines (82 loc) · 2.09 KB
/
ts.go
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
91
92
package api_type
import (
"encoding/json"
"errors"
"fmt"
"reflect"
)
func TsPrimitiveType(typeName string) (string, error) {
switch typeName {
case "string":
return "string", nil
case "int", "int8", "int16", "int32", "uint", "uint8", "uint16", "uint32", "int64", "uint64":
return "number", nil
case "float", "float32", "float64":
return "number", nil
case "bool":
return "boolean", nil
case "[]byte":
return "Blob", nil
case "interface{}":
return "any", nil
}
return "", errors.New("unsupported primitive type " + typeName)
}
func TsRawType(typeName string) (string, error) {
t, err := TsPrimitiveType(typeName)
if err == nil {
return "", errors.New(typeName + " is not raw type")
}
return t, nil
}
func TsType(typeName string) string {
t, err := TsPrimitiveType(typeName)
if err == nil {
return t
}
return typeName
}
func genTsMemberType(m reflect.Type) (typ string, err error) {
typ, err = ToTypeScriptType(m)
return
}
func ToTypeScriptType(typ reflect.Type) (string, error) {
switch typ.Kind() {
case reflect.Struct:
v := reflect.New(typ).Interface()
_, unmar := v.(json.Unmarshaler)
_, mar := v.(json.Marshaler)
if unmar && mar {
return "string", nil
}
return typ.Name(), nil
case reflect.String, reflect.Bool, reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32,
reflect.Int64, reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64,
reflect.Float32, reflect.Float64:
r, err := TsPrimitiveType(typ.Kind().String())
if err != nil {
return "", err
}
return r, nil
case reflect.Map:
valueType, err := ToTypeScriptType(typ.Elem())
if err != nil {
return "", err
}
return fmt.Sprintf("{ [key: string]: %s }", valueType), nil
case reflect.Array, reflect.Slice:
if typ.Name() == "[]byte" {
return "Blob", nil
}
valueType, err := ToTypeScriptType(typ.Elem())
if err != nil {
return "", err
}
return fmt.Sprintf(`Array<%s>`, valueType), nil
case reflect.Interface:
return "any", nil
case reflect.Ptr:
return ToTypeScriptType(typ.Elem())
}
return "", errors.New("unsupported type " + typ.Name())
}