Method convertType

v2/internal/typescriptify/typescriptify.go:633–829

(depth int, typeOf reflect.Type, customCode map[string]string)

}

func (t *TypeScriptify) convertType(depth int, typeOf reflect.Type, customCode map[string]string) (string, error) {
	if _, found := t.alreadyConverted[typeOf.String()]; found { // Already converted
		return "", nil
	}
	fields := t.deepFields(typeOf)
	t.logf(depth, "Converting type %s", typeOf.String())
	if differentNamespaces(t.Namespace, typeOf) {
		return "", nil
	}

	t.alreadyConverted[typeOf.String()] = true

	entityName := t.Prefix + nameTypeOf(typeOf) + t.Suffix

	if typeClashWithReservedKeyword(entityName) {
		warnAboutTypesClash(entityName)
	}

	result := ""
	if t.CreateInterface {
		result += fmt.Sprintf("interface %s {\n", entityName)
	} else {
		result += fmt.Sprintf("class %s {\n", entityName)
	}
	if !t.DontExport {
		result = "export " + result
	}
	builder := typeScriptClassBuilder{
		types:     t.kinds,
		indent:    t.Indent,
		prefix:    t.Prefix,
		suffix:    t.Suffix,
		namespace: t.Namespace,
	}

	for _, field := range fields {
		isPtr := field.Type.Kind() == reflect.Ptr
		if isPtr {
			field.Type = field.Type.Elem()
		}
		jsonFieldName := t.getJSONFieldName(field, isPtr)
		if len(jsonFieldName) == 0 || jsonFieldName == "-" {
			continue
		}

		var err error
		fldOpts := t.getFieldOptions(typeOf, field)
		if fldOpts.TSTransform != "" {
			t.logf(depth, "- simple field %s.%s", typeOf.Name(), field.Name)
			err = builder.AddSimpleField(jsonFieldName, field, fldOpts)
		} else if _, isEnum := t.enums[field.Type]; isEnum {
			t.logf(depth, "- enum field %s.%s", typeOf.Name(), field.Name)
			builder.AddEnumField(jsonFieldName, field)
		} else if fldOpts.TSType != "" { // Struct:
			t.logf(depth, "- simple field %s.%s", typeOf.Name(), field.Name)
			err = builder.AddSimpleField(jsonFieldName, field, fldOpts)
		} else if field.Type.Kind() == reflect.Struct { // Struct:
			t.logf(depth, "- struct %s.%s (%s)", typeOf.Name(), field.Name, field.Type.String())