Generate `type`s instead of `interface`s and `enum`s

[gustavo-shigueo]

Is it possible to generate TypeScript ´typedeclarations instead ofinterface`s? If not can it be added to the library similar to this:

[TsType]
class Foo {
    int Bar;
}

type Foo = { Bar: number }

[zolakt]

Enums to types would be a great addition.
Maybe someone has an existing workaround for that?

[pavel-b-novikov]

For types support there should be implemented additional synax nodes. Unfortunately, I don't have time currently for such a change :(

Actually it can be done using exising architecture even without modifying the source code. I would appreciate if someone will do that in a way I could integrate it into the product

[gustavo-shigueo]

Enums to types would be a great addition. Maybe someone has an existing workaround for that?

Yes! Having type unions instead of TS enums would be very handy, especially given how bad TS enums are sometimes

[gustavo-shigueo]

For types support there should be implemented additional synax nodes.

At the time I opened the issue I attempted to create an AST node for types but couldn't quite figure out how to properly integrate it with the library

Unfortunately, I don't have time currently for such a change :(

I understand, maintaining OSS is really difficult, especially with all the other stuff we have to deal with

Actually it can be done using exising architecture even without modifying the source code.

How so? Can you give any pointers to how this could be achieved?

[entith]

I got something working, but this is rough and not well tested. I'm posting it here for reference in case it'll help anyone.

public class RtType : RtInterface { }

[AttributeUsage(AttributeTargets.Class | AttributeTargets.Interface | AttributeTargets.Struct)]
public class TsTypeAttribute : TsInterfaceAttribute
{
    public TsTypeAttribute()
    {
        CodeGeneratorType = typeof(TsTypeCodeGenerator);
        AutoI = false;
    }
}

public class TsTypeCodeGenerator : ClassAndInterfaceGeneratorBase<RtType>
{
    public override RtType GenerateNode(Type element,RtType result, TypeResolver resolver)
    {
        var tc = Context.Project.Blueprint(element).Attr<TsTypeAttribute>();
        if (tc == null) throw new ArgumentException("TsTypeAttribute is not present", "element");
        Export(result, element, resolver, tc);
        return result;
    }
}

public class CustomVisitor : TypeScriptExportVisitor
{
    public CustomVisitor(TextWriter writer, ExportContext exportContext) : base(writer, exportContext) { }

    public override void Visit(RtInterface node)
    {
        if (node is RtType typeNode)
        {
            if (node == null) return;
            Visit(node.Documentation);
            var prev = Context;
            Context = WriterContext.Interface;
            AppendTabs();
            if (node.Export) Write("export ");
            Write("type ");
            Visit(node.Name);
            Write(" = ");
            if (node.Implementees.Count > 0)
            {
                Visit(node.Implementees.First());
                Write(" & ");
            }
            Br(); AppendTabs();
            Write("{"); Br();
            Tab();
            foreach (var rtMember in DoSortMembers(node.Members))
            {
                Visit(rtMember);
            }
            UnTab();
            AppendTabs(); WriteLine("}");
            Context = prev;
        }
        else
        {
            base.Visit(node);
        }
    }
}


[assembly: TsGlobal(VisitorType = typeof(CustomVisitor))]

Mainly just copied and extended the existing interface code. Don't have time at the moment to make this PR-worthy but I will try to revisit this at some point in the future.