Reinforced.Typings naming conflict for multi-file setup

Question

I have the following classes:

namespace MyApp
{
    public class Class1
    {
        public Nested.Class1 MyProperty { get; set; }
    }
}

namespace MyApp.Nested
{
    public class Class1
    {
        public int MyProperty { get; set; }
    }
}

Fluent config:

public static void Configure(ConfigurationBuilder builder)
{
    builder.Global(conf => conf.UseModules());

    builder.ExportAsInterface<Class1>().WithPublicProperties();
    builder.ExportAsInterface<Nested.Class1>().WithPublicProperties();
}

Which is translated to the following:

// ./Nested/IClass1.ts
export interface IClass1
{
    MyProperty: number;
}

// ./IClass1.ts
import { IClass1 } from './Nested/IClass1';

export interface IClass1
{
    MyProperty: IClass1;
}

As you can see there is a naming conflict for IClass1. The question is, is it possible to overcome this somehow? Maybe to generate something like this:

import * as _IClass1 from './Nested/IClass1';

export interface IClass1
{
    MyProperty: _IClass1.IClass1;
}

Answer 1

After giving it some thought I finally came up with the following:

private class MyInterfaceGenerator : InterfaceCodeGenerator
{
    public override RtInterface GenerateNode(Type element, RtInterface result, TypeResolver resolver)
    {
        var node = base.GenerateNode(element, result, resolver);
        var typeName = node.Name.TypeName;

        typeName = typeName.Substring(typeName.IndexOf('.') + 1);

        node.Name = new RtSimpleTypeName(node.Name.GenericArguments, node.Name.Prefix, typeName);

        return node;
    }
}

private class MyEnumGenerator : EnumGenerator
{
    public override RtEnum GenerateNode(Type element, RtEnum result, TypeResolver resolver)
    {
        var resultEnum = base.GenerateNode(element, result, resolver);

        var typeName = resultEnum.EnumName.TypeName;

        typeName = typeName.Substring(typeName.IndexOf('.') + 1);

        resultEnum.EnumName = new RtSimpleTypeName(resultEnum.EnumName.GenericArguments, resultEnum.EnumName.Prefix, typeName);

        return resultEnum;
    }
}

private class MyRefProcessor : ReferenceProcessorBase
{
    public override IEnumerable<RtImport> FilterImports(IEnumerable<RtImport> imports, ExportedFile file)
    {
        foreach (var import in imports)
        {
            import.Target = "* as " + import.Target.Substring(2, import.Target.IndexOf(".") - 2);
        }

        return imports;
    }

    public override IEnumerable<RtReference> FilterReferences(IEnumerable<RtReference> references, ExportedFile file)
    {
        return references;
    }
}

private static string StripGeneric(string name)
{
    var index = name.IndexOf('`');
    return index == -1 ? name : name.Substring(0, index);
}

private static string NormalizeTypeName(Type type)
{
    return StripGeneric(type.FullName).Replace('.', '_').Replace('+', '_') + "." + StripGeneric(type.Name);
}

private static string NormalizeFileName(Type type)
{
    var result = type.FullName.Replace('.', '/').Replace('+', '_');

    return result + ".ts";
}

public static void Configure(ConfigurationBuilder builder)
{
    builder.Global(conf => 
        conf.UseModules()
            .WithReferencesProcessor<MyRefProcessor>()
    );

    builder.ExportAsInterfaces(
        interfaceTypes,
        conf =>
        {
            conf.WithCodeGenerator<MyInterfaceGenerator>()
                .ExportTo(NormalizeFileName(conf.Type))
                .OverrideName(NormalizeTypeName(conf.Type));
        }
    );

    builder.ExportAsEnums(
        enumTypes,
        conf =>
        {
            conf.WithCodeGenerator<MyEnumGenerator>()
                .ExportTo(NormalizeFileName(conf.Type))
                .OverrideName(NormalizeTypeName(conf.Type));
        }
    );
}

Obviously this is not what the author of the library intended, however this workaround seems to solve all naming conflicts that I had.