Merge branch 'bugfix/problem_with_types_defined_in_external_libs'

Denis Peshkov · Denis Peshkov · commit 5e3ade5c3a97 · 2018-08-13T15:55:55.000+03:00
diff --git a/TypeScriptDefinitionGenerator.sln.DotSettings b/TypeScriptDefinitionGenerator.sln.DotSettings
@@ -0,0 +1,2 @@
+﻿<wpf:ResourceDictionary xml:space="preserve" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:s="clr-namespace:System;assembly=mscorlib" xmlns:ss="urn:shemas-jetbrains-com:settings-storage-xaml" xmlns:wpf="http://schemas.microsoft.com/winfx/2006/xaml/presentation">
+	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/Abbreviations/=TS/@EntryIndexedValue">TS</s:String></wpf:ResourceDictionary>
diff --git a/src/TypeScriptDefinitionGenerator/Constants.cs b/src/TypeScriptDefinitionGenerator/Constants.cs
@@ -2,7 +2,6 @@
 {
     public static class Constants
     {
-        public const string FileExtension = ".generated.d.ts";
         public static string[] SupportedSourceExtensions { get; } = { ".cs" };
     }
 }
diff --git a/src/TypeScriptDefinitionGenerator/Generator/DtsGenerator.cs b/src/TypeScriptDefinitionGenerator/Generator/DtsGenerator.cs
@@ -4,6 +4,7 @@
 using System.IO;
 using System.Runtime.InteropServices;
 using System.Text;
+using TypeScriptDefinitionGenerator.Helpers;
 
 namespace TypeScriptDefinitionGenerator
 {
@@ -17,14 +18,7 @@ public sealed class DtsGenerator : BaseCodeGeneratorWithSite
 
         public override string GetDefaultExtension()
         {
-            if (Options.WebEssentials2015)
-            {
-                return this.originalExt + Constants.FileExtension;
-            }
-            else
-            {
-                return Constants.FileExtension;
-            }
+            return Utility.GetDefaultExtension(this.originalExt);
         }
 
         protected override byte[] GenerateCode(string inputFileName, string inputFileContent)
diff --git a/src/TypeScriptDefinitionGenerator/Generator/IntellisenseType.cs b/src/TypeScriptDefinitionGenerator/Generator/IntellisenseType.cs
@@ -33,18 +33,13 @@ public class IntellisenseType
         /// </summary>
         public IEnumerable<IntellisenseProperty> Shape { get; set; }
 
-        public bool IsKnownType
-        {
-            get { return TypeScriptName != "any"; }
-        }
+        public bool IsKnownType { get { return TypeScriptName != "any"; } }
         
         public string TypeScriptName
         {
             get
             {
-                if (IsDictionary)
-                    return GetKVPTypes();
-                return GetTargetName(CodeName, false);
+                return IsDictionary ? GetKVPTypes() : GetTargetName(CodeName, false);
             }
         }
 
diff --git a/src/TypeScriptDefinitionGenerator/Generator/IntellisenseWriter.cs b/src/TypeScriptDefinitionGenerator/Generator/IntellisenseWriter.cs
@@ -22,42 +22,32 @@ public static string WriteTypeScript(IEnumerable<IntellisenseObject> objects)
 
             foreach (var ns in objects.GroupBy(o => o.Namespace))
             {
-                if (!Options.GlobalScope)
+                if (Options.DeclareModule)
                 {
                     sb.AppendFormat("declare module {0} {{\r\n", ns.Key);
                 }
 
+                string export = !Options.DeclareModule ? "export " : string.Empty;
+                string prefixModule = Options.DeclareModule ? "\t" : String.Empty;
+
                 foreach (IntellisenseObject io in ns)
                 {
                     if (!string.IsNullOrEmpty(io.Summary))
-                        sb.AppendLine("\t/** " + _whitespaceTrimmer.Replace(io.Summary, "") + " */");
+                        sb.Append(prefixModule).AppendLine("/** " + _whitespaceTrimmer.Replace(io.Summary, "") + " */");
 
                     if (io.IsEnum)
                     {
-                        string export = Options.Export ? "export " : string.Empty;
-                        sb.AppendLine("\t" + export + "const enum " + Utility.CamelCaseClassName(io.Name) + " {");
+                        string type = "enum ";
+                        sb.Append(prefixModule).Append(export).Append(type).Append(Utility.CamelCaseClassName(io.Name)).Append(" ");
 
-                        foreach (var p in io.Properties)
-                        {
-                            WriteTypeScriptComment(p, sb);
-
-                            if (p.InitExpression != null)
-                            {
-                                sb.AppendLine("\t\t" + Utility.CamelCaseEnumValue(p.Name) + " = " + CleanEnumInitValue(p.InitExpression) + ",");
-                            }
-                            else
-                            {
-                                sb.AppendLine("\t\t" + Utility.CamelCaseEnumValue(p.Name) + ",");
-                            }
-                        }
-
-                        sb.AppendLine("\t}");
+                        sb.AppendLine("{");
+                        WriteTSEnumDefinition(sb, prefixModule + "\t", io.Properties);
+                        sb.Append(prefixModule).AppendLine("}");
                     }
                     else
                     {
                         string type = Options.ClassInsteadOfInterface ? "class " : "interface ";
-                        string export = Options.Export ? "export " : string.Empty;
-                        sb.Append("\t").Append(export).Append(type).Append(Utility.CamelCaseClassName(io.Name)).Append(" ");
+                        sb.Append(prefixModule).Append(export).Append(type).Append(Utility.CamelCaseClassName(io.Name)).Append(" ");
 
                         if (!string.IsNullOrEmpty(io.BaseName))
                         {
@@ -69,12 +59,13 @@ public static string WriteTypeScript(IEnumerable<IntellisenseObject> objects)
                             sb.Append(Utility.CamelCaseClassName(io.BaseName)).Append(" ");
                         }
 
-                        WriteTSInterfaceDefinition(sb, "\t", io.Properties);
-                        sb.AppendLine();
+                        sb.AppendLine("{");
+                        WriteTSInterfaceDefinition(sb, prefixModule + "\t", io.Properties);
+                        sb.Append(prefixModule).AppendLine("}");
                     }
                 }
 
-                if (!Options.GlobalScope)
+                if (Options.DeclareModule)
                 {
                     sb.AppendLine("}");
                 }
@@ -91,36 +82,48 @@ private static string CleanEnumInitValue(string value)
             if (trimedValue.Length > 0) return trimedValue;
             return "0";
         }
-
-
-        private static void WriteTypeScriptComment(IntellisenseProperty p, StringBuilder sb)
+        
+        private static void WriteTypeScriptComment(IntellisenseProperty p, StringBuilder sb, string prefix)
         {
             if (string.IsNullOrEmpty(p.Summary)) return;
-            sb.AppendLine("\t\t/** " + _whitespaceTrimmer.Replace(p.Summary, "") + " */");
+            sb.Append(prefix).AppendLine("/** " + _whitespaceTrimmer.Replace(p.Summary, "") + " */");
         }
 
-        private static void WriteTSInterfaceDefinition(StringBuilder sb, string prefix,
-            IEnumerable<IntellisenseProperty> props)
+        private static void WriteTSEnumDefinition(StringBuilder sb, string prefix, IEnumerable<IntellisenseProperty> props)
         {
-            sb.AppendLine("{");
+            foreach (var p in props)
+            {
+                WriteTypeScriptComment(p, sb, prefix);
 
+                if (p.InitExpression != null)
+                {
+                    sb.AppendLine(prefix + Utility.CamelCaseEnumValue(p.Name) + " = " + CleanEnumInitValue(p.InitExpression) + ",");
+                }
+                else
+                {
+                    sb.AppendLine(prefix + Utility.CamelCaseEnumValue(p.Name) + ",");
+                }
+            }
+
+        }
+
+        private static void WriteTSInterfaceDefinition(StringBuilder sb, string prefix, IEnumerable<IntellisenseProperty> props)
+        {
             foreach (var p in props)
             {
-                WriteTypeScriptComment(p, sb);
-                sb.AppendFormat("{0}\t{1}: ", prefix, Utility.CamelCasePropertyName(p.NameWithOption));
+                WriteTypeScriptComment(p, sb, prefix);
+                sb.AppendFormat("{0}{1}: ", prefix, Utility.CamelCasePropertyName(p.NameWithOption));
 
                 if (p.Type.IsKnownType) sb.Append(p.Type.TypeScriptName);
                 else
                 {
                     if (p.Type.Shape == null) sb.Append("any");
-                    else WriteTSInterfaceDefinition(sb, prefix + "\t", p.Type.Shape);
+                    else WriteTSInterfaceDefinition(sb, prefix, p.Type.Shape);
                 }
                 if (p.Type.IsArray) sb.Append("[]");
 
                 sb.AppendLine(";");
             }
-
-            sb.Append(prefix).Append("}");
         }
     }
 }
diff --git a/src/TypeScriptDefinitionGenerator/Helpers/Utility.cs b/src/TypeScriptDefinitionGenerator/Helpers/Utility.cs
@@ -7,14 +7,19 @@ internal static class Utility
     {
         public static string GenerateFileName(string sourceFile)
         {
+            return Path.ChangeExtension(sourceFile, GetDefaultExtension(Path.GetExtension(sourceFile)));
+        }
+
+        public static string GetDefaultExtension(string originalExt)
+        {
+            string declaredExt = Options.DeclareModule ? ".d" : string.Empty;
+            string ext = $".generated{declaredExt}.ts";
+
             if (Options.WebEssentials2015)
             {
-                return sourceFile + Constants.FileExtension;
-            }
-            else
-            {
-                return Path.ChangeExtension(sourceFile, Constants.FileExtension);
+                return originalExt + ext;
             }
+            return ext;
         }
 
         public static string CamelCaseClassName(string name)
diff --git a/src/TypeScriptDefinitionGenerator/Options.cs b/src/TypeScriptDefinitionGenerator/Options.cs
@@ -17,8 +17,7 @@ public class OptionsDialogPage : DialogPage
 
         internal const bool _defClassInsteadOfInterface = false;
         internal const string _defModuleName = "Server.Dtos";
-        internal const bool _defExport = false;
-        internal const bool _defGlobalScope = false;
+        internal const bool _defDeclareModule = true;
         internal const bool _defIgnoreIntellisense = true;
 
         [Category("Casing")]
@@ -35,6 +34,12 @@ public class OptionsDialogPage : DialogPage
         [DisplayName("Camel case type names")]
         [DefaultValue(_defCamelCaseTypeNames)]
         public bool CamelCaseTypeNames { get; set; } = _defCamelCaseTypeNames;
+        
+        [Category("Compatibilty")]
+        [DisplayName("Web Essentials 2015 file names")]
+        [Description("Web Essentials 2015 format is <filename>.cs.d.ts instead of <filename>.d.ts")]
+        [DefaultValue(_defWebEssentials2015)]
+        public bool WebEssentials2015 { get; set; } = _defWebEssentials2015;
 
         [Category("Settings")]
         [DisplayName("Default Module name")]
@@ -48,28 +53,16 @@ public class OptionsDialogPage : DialogPage
         public bool ClassInsteadOfInterface { get; set; } = _defClassInsteadOfInterface;
 
         [Category("Settings")]
-        [DisplayName("Generate in global scope")]
-        [Description("Controls whether to generate types in Global scope or wrapped in a module")]
-        [DefaultValue(_defGlobalScope)]
-        public bool GlobalScope { get; set; } = _defGlobalScope;
-
-        [Category("Settings")]
-        [DisplayName("Export elements")]
-        [Description("Controls whether to do export elements")]
-        [DefaultValue(_defExport)]
-        public bool Export { get; set; } = _defExport;
+        [DisplayName("Declare module")]
+        [Description("Controls whether to generate types in declared module or without one, but with export")]
+        [DefaultValue(_defDeclareModule)]
+        public bool DeclareModule { get; set; } = _defDeclareModule;
 
         [Category("Settings")]
         [DisplayName("Ignore intellisense")]
         [Description("Ignore intellisense for client side reference names")]
         [DefaultValue(_defIgnoreIntellisense)]
         public bool IgnoreIntellisense { get; set; } = _defIgnoreIntellisense;
-        
-        [Category("Compatibilty")]
-        [DisplayName("Web Esentials 2015 file names")]
-        [Description("Web Essentials 2015 format is <filename>.cs.d.ts instead of <filename>.d.ts")]
-        [DefaultValue(_defWebEssentials2015)]
-        public bool WebEssentials2015 { get; set; } = _defWebEssentials2015;
     }
 
     public class Options
@@ -116,19 +109,11 @@ public static bool ClassInsteadOfInterface
             }
         }
 
-        public static bool GlobalScope
-        {
-            get
-            {
-                return overrides != null ? overrides.GlobalScope : DtsPackage.Options.GlobalScope;
-            }
-        }
-
-        public static bool Export
+        public static bool DeclareModule
         {
             get
             {
-                return overrides != null ? overrides.Export : DtsPackage.Options.Export;
+                return overrides != null ? overrides.DeclareModule : DtsPackage.Options.DeclareModule;
             }
         }
 
@@ -224,10 +209,7 @@ internal class OptionsOverride
         public bool ClassInsteadOfInterface { get; set; } = OptionsDialogPage._defClassInsteadOfInterface;
 
         //        [JsonRequired]
-        public bool GlobalScope { get; set; } = OptionsDialogPage._defGlobalScope;
-
-        //        [JsonRequired]
-        public bool Export { get; set; } = OptionsDialogPage._defExport;
+        public bool DeclareModule { get; set; } = OptionsDialogPage._defDeclareModule;
 
         //        [JsonRequired]
         public bool IgnoreIntellisense { get; set; } = OptionsDialogPage._defIgnoreIntellisense;
diff --git a/tests/ClassLibrary1/SomeClass.cs b/tests/ClassLibrary1/SomeClass.cs
@@ -3,5 +3,7 @@
     public class SomeClass
     {
         public int Inc1 { get; set; }
+
+        public SomeEnum Some { get; set; }
     }
 }
diff --git a/tests/TypeScriptDefinitionGenerator.Tests/IntellisenseParserTest.cs b/tests/TypeScriptDefinitionGenerator.Tests/IntellisenseParserTest.cs
@@ -60,8 +60,7 @@ public void _ShouldWorkProperly()
 
                 ClassInsteadOfInterface = false,
                 DefaultModuleName = "Server.Dtos",
-                Export = false,
-                GlobalScope = false,
+                DeclareModule = true,
                 IgnoreIntellisense = true,
             });
             var list = IntellisenseParser.ProcessFile(item).ToList();

Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,2 @@`
	`1`	`+<wpf:ResourceDictionary xml:space="preserve" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:s="clr-namespace:System;assembly=mscorlib" xmlns:ss="urn:shemas-jetbrains-com:settings-storage-xaml" xmlns:wpf="http://schemas.microsoft.com/winfx/2006/xaml/presentation">`
	`2`	`+ <s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/Abbreviations/=TS/@EntryIndexedValue">TS</s:String></wpf:ResourceDictionary>`
Original file line number	Diff line number	Diff line change
`@@ -2,7 +2,6 @@`
`2`	`2`	`{`
`3`	`3`	`public static class Constants`
`4`	`4`	`{`
`5`		`- public const string FileExtension = ".generated.d.ts";`
`6`	`5`	`public static string[] SupportedSourceExtensions { get; } = { ".cs" };`
`7`	`6`	`}`
`8`	`7`	`}`
Original file line number	Diff line number	Diff line change
`@@ -33,18 +33,13 @@ public class IntellisenseType`
`33`	`33`	`/// </summary>`
`34`	`34`	`public IEnumerable<IntellisenseProperty> Shape { get; set; }`
`35`	`35`
`36`		`- public bool IsKnownType`
`37`		`- {`
`38`		`- get { return TypeScriptName != "any"; }`
`39`		`- }`
	`36`	`+ public bool IsKnownType { get { return TypeScriptName != "any"; } }`
`40`	`37`
`41`	`38`	`public string TypeScriptName`
`42`	`39`	`{`
`43`	`40`	`get`
`44`	`41`	`{`
`45`		`- if (IsDictionary)`
`46`		`- return GetKVPTypes();`
`47`		`- return GetTargetName(CodeName, false);`
	`42`	`+ return IsDictionary ? GetKVPTypes() : GetTargetName(CodeName, false);`
`48`	`43`	`}`
`49`	`44`	`}`
`50`	`45`
Original file line number	Diff line number	Diff line change
`@@ -22,42 +22,32 @@ public static string WriteTypeScript(IEnumerable<IntellisenseObject> objects)`
`22`	`22`
`23`	`23`	`foreach (var ns in objects.GroupBy(o => o.Namespace))`
`24`	`24`	`{`
`25`		`- if (!Options.GlobalScope)`
	`25`	`+ if (Options.DeclareModule)`
`26`	`26`	`{`
`27`	`27`	`sb.AppendFormat("declare module {0} {{\r\n", ns.Key);`
`28`	`28`	`}`
`29`	`29`
	`30`	`+ string export = !Options.DeclareModule ? "export " : string.Empty;`
	`31`	`+ string prefixModule = Options.DeclareModule ? "\t" : String.Empty;`
	`32`	`+`
`30`	`33`	`foreach (IntellisenseObject io in ns)`
`31`	`34`	`{`
`32`	`35`	`if (!string.IsNullOrEmpty(io.Summary))`
`33`		`- sb.AppendLine("\t/** " + _whitespaceTrimmer.Replace(io.Summary, "") + " */");`
	`36`	`+ sb.Append(prefixModule).AppendLine("/** " + _whitespaceTrimmer.Replace(io.Summary, "") + " */");`
`34`	`37`
`35`	`38`	`if (io.IsEnum)`
`36`	`39`	`{`
`37`		`- string export = Options.Export ? "export " : string.Empty;`
`38`		`- sb.AppendLine("\t" + export + "const enum " + Utility.CamelCaseClassName(io.Name) + " {");`
	`40`	`+ string type = "enum ";`
	`41`	`+ sb.Append(prefixModule).Append(export).Append(type).Append(Utility.CamelCaseClassName(io.Name)).Append(" ");`
`39`	`42`
`40`		`- foreach (var p in io.Properties)`
`41`		`- {`
`42`		`- WriteTypeScriptComment(p, sb);`
`43`		`-`
`44`		`- if (p.InitExpression != null)`
`45`		`- {`
`46`		`- sb.AppendLine("\t\t" + Utility.CamelCaseEnumValue(p.Name) + " = " + CleanEnumInitValue(p.InitExpression) + ",");`
`47`		`- }`
`48`		`- else`
`49`		`- {`
`50`		`- sb.AppendLine("\t\t" + Utility.CamelCaseEnumValue(p.Name) + ",");`
`51`		`- }`
`52`		`- }`
`53`		`-`
`54`		`- sb.AppendLine("\t}");`
	`43`	`+ sb.AppendLine("{");`
	`44`	`+ WriteTSEnumDefinition(sb, prefixModule + "\t", io.Properties);`
	`45`	`+ sb.Append(prefixModule).AppendLine("}");`
`55`	`46`	`}`
`56`	`47`	`else`
`57`	`48`	`{`
`58`	`49`	`string type = Options.ClassInsteadOfInterface ? "class " : "interface ";`
`59`		`- string export = Options.Export ? "export " : string.Empty;`
`60`		`- sb.Append("\t").Append(export).Append(type).Append(Utility.CamelCaseClassName(io.Name)).Append(" ");`
	`50`	`+ sb.Append(prefixModule).Append(export).Append(type).Append(Utility.CamelCaseClassName(io.Name)).Append(" ");`
`61`	`51`
`62`	`52`	`if (!string.IsNullOrEmpty(io.BaseName))`
`63`	`53`	`{`
`@@ -69,12 +59,13 @@ public static string WriteTypeScript(IEnumerable<IntellisenseObject> objects)`
`69`	`59`	`sb.Append(Utility.CamelCaseClassName(io.BaseName)).Append(" ");`
`70`	`60`	`}`
`71`	`61`
`72`		`- WriteTSInterfaceDefinition(sb, "\t", io.Properties);`
`73`		`- sb.AppendLine();`
	`62`	`+ sb.AppendLine("{");`
	`63`	`+ WriteTSInterfaceDefinition(sb, prefixModule + "\t", io.Properties);`
	`64`	`+ sb.Append(prefixModule).AppendLine("}");`
`74`	`65`	`}`
`75`	`66`	`}`
`76`	`67`
`77`		`- if (!Options.GlobalScope)`
	`68`	`+ if (Options.DeclareModule)`
`78`	`69`	`{`
`79`	`70`	`sb.AppendLine("}");`
`80`	`71`	`}`
`@@ -91,36 +82,48 @@ private static string CleanEnumInitValue(string value)`
`91`	`82`	`if (trimedValue.Length > 0) return trimedValue;`
`92`	`83`	`return "0";`
`93`	`84`	`}`
`94`		`-`
`95`		`-`
`96`		`- private static void WriteTypeScriptComment(IntellisenseProperty p, StringBuilder sb)`
	`85`	`+`
	`86`	`+ private static void WriteTypeScriptComment(IntellisenseProperty p, StringBuilder sb, string prefix)`
`97`	`87`	`{`
`98`	`88`	`if (string.IsNullOrEmpty(p.Summary)) return;`
`99`		`- sb.AppendLine("\t\t/** " + _whitespaceTrimmer.Replace(p.Summary, "") + " */");`
	`89`	`+ sb.Append(prefix).AppendLine("/** " + _whitespaceTrimmer.Replace(p.Summary, "") + " */");`
`100`	`90`	`}`
`101`	`91`
`102`		`- private static void WriteTSInterfaceDefinition(StringBuilder sb, string prefix,`
`103`		`- IEnumerable<IntellisenseProperty> props)`
	`92`	`+ private static void WriteTSEnumDefinition(StringBuilder sb, string prefix, IEnumerable<IntellisenseProperty> props)`
`104`	`93`	`{`
`105`		`- sb.AppendLine("{");`
	`94`	`+ foreach (var p in props)`
	`95`	`+ {`
	`96`	`+ WriteTypeScriptComment(p, sb, prefix);`
`106`	`97`
	`98`	`+ if (p.InitExpression != null)`
	`99`	`+ {`
	`100`	`+ sb.AppendLine(prefix + Utility.CamelCaseEnumValue(p.Name) + " = " + CleanEnumInitValue(p.InitExpression) + ",");`
	`101`	`+ }`
	`102`	`+ else`
	`103`	`+ {`
	`104`	`+ sb.AppendLine(prefix + Utility.CamelCaseEnumValue(p.Name) + ",");`
	`105`	`+ }`
	`106`	`+ }`
	`107`	`+`
	`108`	`+ }`
	`109`	`+`
	`110`	`+ private static void WriteTSInterfaceDefinition(StringBuilder sb, string prefix, IEnumerable<IntellisenseProperty> props)`
	`111`	`+ {`
`107`	`112`	`foreach (var p in props)`
`108`	`113`	`{`
`109`		`- WriteTypeScriptComment(p, sb);`
`110`		`- sb.AppendFormat("{0}\t{1}: ", prefix, Utility.CamelCasePropertyName(p.NameWithOption));`
	`114`	`+ WriteTypeScriptComment(p, sb, prefix);`
	`115`	`+ sb.AppendFormat("{0}{1}: ", prefix, Utility.CamelCasePropertyName(p.NameWithOption));`
`111`	`116`
`112`	`117`	`if (p.Type.IsKnownType) sb.Append(p.Type.TypeScriptName);`
`113`	`118`	`else`
`114`	`119`	`{`
`115`	`120`	`if (p.Type.Shape == null) sb.Append("any");`
`116`		`- else WriteTSInterfaceDefinition(sb, prefix + "\t", p.Type.Shape);`
	`121`	`+ else WriteTSInterfaceDefinition(sb, prefix, p.Type.Shape);`
`117`	`122`	`}`
`118`	`123`	`if (p.Type.IsArray) sb.Append("[]");`
`119`	`124`
`120`	`125`	`sb.AppendLine(";");`
`121`	`126`	`}`
`122`		`-`
`123`		`- sb.Append(prefix).Append("}");`
`124`	`127`	`}`
`125`	`128`	`}`
`126`	`129`	`}`
Original file line number	Diff line number	Diff line change
`@@ -7,14 +7,19 @@ internal static class Utility`
`7`	`7`	`{`
`8`	`8`	`public static string GenerateFileName(string sourceFile)`
`9`	`9`	`{`
	`10`	`+ return Path.ChangeExtension(sourceFile, GetDefaultExtension(Path.GetExtension(sourceFile)));`
	`11`	`+ }`
	`12`	`+`
	`13`	`+ public static string GetDefaultExtension(string originalExt)`
	`14`	`+ {`
	`15`	`+ string declaredExt = Options.DeclareModule ? ".d" : string.Empty;`
	`16`	`+ string ext = $".generated{declaredExt}.ts";`
	`17`	`+`
`10`	`18`	`if (Options.WebEssentials2015)`
`11`	`19`	`{`
`12`		`- return sourceFile + Constants.FileExtension;`
`13`		`- }`
`14`		`- else`
`15`		`- {`
`16`		`- return Path.ChangeExtension(sourceFile, Constants.FileExtension);`
	`20`	`+ return originalExt + ext;`
`17`	`21`	`}`
	`22`	`+ return ext;`
`18`	`23`	`}`
`19`	`24`
`20`	`25`	`public static string CamelCaseClassName(string name)`
Original file line number	Diff line number	Diff line change
`@@ -3,5 +3,7 @@`
`3`	`3`	`public class SomeClass`
`4`	`4`	`{`
`5`	`5`	`public int Inc1 { get; set; }`
	`6`	`+`
	`7`	`+ public SomeEnum Some { get; set; }`
`6`	`8`	`}`
`7`	`9`	`}`