搞搞就懂

<#@ template debug="false" hostspecific="true" language="C#" #>
<#@ assembly name="System.Core" #>
<#@ assembly name="EnvDte" #>
<#@ import namespace="EnvDTE" #>
<#@ import namespace="System.Linq" #>
<#@ import namespace="System.Text" #>
<#@ import namespace="System.Collections.Generic" #>
<#@ import namespace="System.Text.RegularExpressions" #>
<#@ output extension=".js" #>

<#
	#region Target Enum Filter Conditions

	var jsRootNamespace = "myProject";

	// target project names (empty : for all projects)
	List<string> includeProjects = new List<string>(){
		//"T4EnumJsWebApp",
		//"Domain"
	};

	// target enum name spaces (empty : for all enums)
	List<string> includeEnumNameSpaces = new List<string>(){
		//"Domain.Enums"
    };

	// target enum full names (empty : for all enums)
	List<string> includeFullEnumNames = new List<string>(){
		//"Domain.Enums.BarrierType"
    };

    #endregion


#>
var <#= jsRootNamespace #> = <#= jsRootNamespace #> || {};

(function () {

	<#= jsRootNamespace #>.enums = <#= jsRootNamespace #>.enums || {};

<#
    


	// browse every solution's projects
    var visualStudio = (Host as IServiceProvider).GetService(typeof(EnvDTE.DTE)) as EnvDTE.DTE;
	foreach(EnvDTE.Project project in visualStudio.Solution.Projects)
    {

		// filter by pre-define project name
        if (includeProjects.Count > 0)
        {
			string projectName = project.Name;
			if(!includeProjects.Contains(projectName))
            { continue; }
        }

		// browse every project's files
		foreach(EnvDTE.ProjectItem item in GetProjectItemsRecursively(project.ProjectItems))
		{
			//string fileName = item.Name;
			if (item.FileCodeModel == null) continue;
			foreach(EnvDTE.CodeElement elem in item.FileCodeModel.CodeElements)
			{

				if (elem.Kind == EnvDTE.vsCMElement.vsCMElementNamespace)
				{
					// filter by pre-define name space
					if (includeEnumNameSpaces.Count > 0)
					{
						string fullEnumNameSpace = elem.FullName;
						if(!includeEnumNameSpaces.Contains(fullEnumNameSpace))
						{ continue; }
					}


					foreach (CodeElement innerElement in elem.Children)
					{

						if (innerElement.Kind == vsCMElement.vsCMElementEnum)
						{
							// filter by pre-define project name
							if (includeFullEnumNames.Count > 0)
							{
								string fullEnumName = innerElement.FullName;
								if(!includeFullEnumNames.Contains(fullEnumName))
								{ continue; }
							}

							// enum
							CodeEnum enu = (CodeEnum)innerElement;

							// format enum name
							string enumName = LowerFirstChar(enu.Name);
							
#>
	<#= jsRootNamespace #>.enums.<#= enumName #> = {
<#

							// deal with each enum members
							int memberIndex = 0, currentEnumValue = 0;
							foreach (CodeElement member in enu.Members)
							{
								bool isLastChlid = false;
								if (memberIndex == enu.Members.Count-1)
								{ isLastChlid = true; }

								// get enum member
								CodeVariable value = member as CodeVariable;

								if (value != null) {

									string init = value.InitExpression as string;
									int unused;
									if (!int.TryParse(init, out unused))
									{
										// not set value for each enum
										// use current value + 1 as enum value
										currentEnumValue += 1;
										init = currentEnumValue.ToString();
									}

									// update current enum value
									currentEnumValue = Convert.ToInt16(init);

									// output enum member
									string finalComma = isLastChlid ? "" : ",";
									WriteLine("\t\t" + LowerFirstChar(value.Name) + ": " + init + finalComma);
								}

								memberIndex++;
							}
#>
    };

<#
						}
					}
				}
			}
		}
	}
#>
})();
<#+
	public List<EnvDTE.ProjectItem> GetProjectItemsRecursively(EnvDTE.ProjectItems items)
	{
		var ret = new List<EnvDTE.ProjectItem>();
		if (items == null) return ret;
		foreach(EnvDTE.ProjectItem item in items)
		{
			ret.Add(item);
			ret.AddRange(GetProjectItemsRecursively(item.ProjectItems));
		}
		return ret;
	}

	public string LowerFirstChar(string originalName)
	{
		// ex. AAA to aaa
		// ex. aaa to aaa
		// ex. aAABbbCccEnum to aAABbbCccEnum
		// ex. AaaBbbCccEnum to aaaBbbCccEnum
		// ex. AAABbbCccEnum to aaaBbbCccEnum

		string name= originalName;
	
		// get first lower char index
		var regex = new Regex("[a-z]", RegexOptions.None); 
		var firstLowerChar = 
				name.AsEnumerable()
				.Select((word, index) => new {word, index})
				.FirstOrDefault(n=> regex.Match(n.word.ToString()).Success);
				
		if (firstLowerChar == null)
		{
			// all upper chars
			name = name.ToLower();
		}
		else
		{
			// has lower char
			var firstLowerCharIndex = firstLowerChar.index;
			if (firstLowerCharIndex > 0)
			{
				// keep upper char before the first lower char
				if (firstLowerCharIndex != 1)
				{ firstLowerCharIndex--; }
			
				// adjust name
				name = name.Substring(0, firstLowerCharIndex).ToLower()
						+  name.Substring(firstLowerCharIndex);
			}
		}
	
		return name;
	}

#>

namespace Domain.Enums
{
    public enum BarrierType
    {
        [Description("American")]
        American = 1,

        [Description("Discrete")]
        Discrete,

        [Description("European")]
        European
    }
}

namespace Domain.Enums
{
    public enum SettleMode
    {
        [Description("Physical")]
        Physical = 1,

        [Description("Cash")]
        Cash
    }
}

var myProject = myProject || {};

(function () {

	myProject.enums = myProject.enums || {};

	myProject.enums.barrierType = {
		american: 1,
		discrete: 2,
		european: 3
    };

	myProject.enums.settleMode = {
		physical: 1,
		cash: 2
    };

})();