private static List <string> GetReferences(IEnumerable <IntellisenseObject> objects, ProjectItem sourceItem)
{
if (Options.KeepReferencesUnchanged)
{
ProjectItem generatedProjectItem = sourceItem.ProjectItems
.Cast <ProjectItem>()
.Where(item => GenerationService.GenerateFileName(sourceItem.Name) == item.Name)
.FirstOrDefault();
if (generatedProjectItem != null)
{
string documentText = VSHelpers.GetDocumentText(generatedProjectItem);
if (string.IsNullOrWhiteSpace(documentText) == false)
{
string pattern = "/// <reference path=\"(.*)\" />\r\n";
return(new Regex(pattern).Matches(documentText)
.Cast <Match>()
.Select(m => m.Groups[1].Value)
.OrderBy(r => r)
.ToList());
}
}
}
return(objects
.SelectMany(o => o.References)
.Where(r => Path.GetFileName(r) != GenerationService.GenerateFileName(sourceItem.Name))
.Distinct()
.OrderBy(r => r)
.ToList());
}
public static void CreateDtsFile(ProjectItem sourceItem)
{
string sourceFile = sourceItem.FileNames[1];
string dtsFile = GenerationService.GenerateFileName(sourceFile);
string dts = ConvertToTypeScript(sourceItem);
VSHelpers.CheckFileOutOfSourceControl(dtsFile);
File.WriteAllText(dtsFile, dts);
if (sourceItem.ContainingProject.IsKind(ProjectTypes.DOTNET_Core, ProjectTypes.ASPNET_5))
{
Dispatcher.CurrentDispatcher.BeginInvoke(new Action(() =>
{
var dtsItem = VSHelpers.GetProjectItem(dtsFile);
if (dtsItem != null)
{
dtsItem.Properties.Item("DependentUpon").Value = sourceItem.Name;
}
Telemetry.TrackOperation("FileGenerated");
}), DispatcherPriority.ApplicationIdle, null);
}
else if (sourceItem.ContainingProject.IsKind(ProjectTypes.WEBSITE_PROJECT))
{
sourceItem.ContainingProject.ProjectItems.AddFromFile(dtsFile);
}
}
protected override byte[] GenerateCode(string inputFileName, string inputFileContent)
{
ProjectItem item = Dte.Solution.FindProjectItem(inputFileName);
this.originalExt = Path.GetExtension(inputFileName);
if (item != null)
{
// Sometimes "DtsPackage.Options"==null at this point. Make sure that options get loaded now.
DtsPackage.EnsurePackageLoad();
try
{
string dts = GenerationService.ConvertToTypeScript(item);
Telemetry.TrackOperation("FileGenerated");
return(Encoding.UTF8.GetBytes(dts));
}
catch (Exception ex)
{
Telemetry.TrackOperation("FileGenerated", Microsoft.VisualStudio.Telemetry.TelemetryResult.Failure);
Telemetry.TrackException("FileGenerated", ex);
}
}
return(new byte[0]);
}
public static void CopyDtsFile(DefinitionMapData definitionMapData, ProjectItem projectItem, string dts, bool isEnumDefinition)
{
// There might be paths where this file should be copied to
foreach (string copyPath in definitionMapData.CopyPaths)
{
// Ignore empty paths
if (string.IsNullOrWhiteSpace(copyPath))
{
continue;
}
// Get the path from our project item and combine it with the target path and target name
string filePath = Path.GetFullPath(Path.Combine(
Path.GetDirectoryName(projectItem.FileNames[1]),
copyPath,
GenerationService.GetCopyDtsFileName(definitionMapData, projectItem, isEnumDefinition)));
// Try to write our definition file to the new path too
try
{
File.WriteAllText(filePath, dts);
VSHelpers.WriteOnOutputWindow($"File written to \"{filePath}\"");
}
catch (Exception ex)
{
VSHelpers.WriteOnOutputWindow($"Could not write file to \"{filePath}\"{Environment.NewLine}" +
$"Reason: {ex.Message}");
}
}
}
internal static DefinitionMapData GetDefinitionMapData(ProjectItem projectItem)
{
// Initialize our result
DefinitionMapData result = null;
// Try to find our map data for the typescript definition file
ProjectItem definitionMapProjectItem = projectItem.ProjectItems
.Cast <ProjectItem>()
.Where(pi => pi.Name == GenerationService.GenerateFileName(projectItem.Name) + ".map")
.FirstOrDefault();
// Continue if found
if (definitionMapProjectItem != null)
{
// Get the text of our mapping file
string documentText = VSHelpers.GetDocumentText(definitionMapProjectItem);
// Continue if the document has text
if (string.IsNullOrWhiteSpace(documentText) == false)
{
// Try to parse the containing json string
// When a SerializationException is getting thrown the document text wasn't valid
try
{
result = JsonConvert.DeserializeObject <DefinitionMapData>(documentText);
}
catch (JsonSerializationException) { }
}
}
return(result);
}
protected override byte[] GenerateCode(string inputFileName, string inputFileContent)
{
ProjectItem item = (Dte as DTE2).Solution.FindProjectItem(inputFileName);
originalExt = Path.GetExtension(inputFileName);
if (item != null)
{
try
{
var dts = GenerationService.ConvertToTypeScript(item);
Telemetry.TrackOperation("FileGenerated");
InsertToIndex(item, Path.GetFileNameWithoutExtension(inputFileName));
return(Encoding.UTF8.GetBytes(dts));
}
catch (Exception ex)
{
Telemetry.TrackOperation("FileGenerated", Microsoft.VisualStudio.Telemetry.TelemetryResult.Failure);
Telemetry.TrackException("FileGenerated", ex);
}
}
return(new byte[0]);
}
public static void CreateDtsFile(ProjectItem sourceItem)
{
string sourceFile = sourceItem.FileNames[1];
string dtsFile = GenerationService.GenerateFileName(sourceFile);
string dtsEnumFile = GenerationService.GenerateFileName(sourceFile);
// Get metadata from our project item
DefinitionMapData definitionMapData = VSHelpers.GetDefinitionMapData(sourceItem);
string dts = ConvertToTypeScriptWithoutEnums(sourceItem, ref definitionMapData, out bool isEmpty);
string dtsEnumOnly = ConvertToTypeScriptEnumsOnly(sourceItem, ref definitionMapData, out bool isEmptyEnum);
VSHelpers.CheckFileOutOfSourceControl(dtsFile);
File.WriteAllText(dtsFile, dts);
if (isEmptyEnum == false)
{
File.WriteAllText(dtsEnumFile, dtsEnumOnly);
}
if (sourceItem.ContainingProject.IsKind(ProjectTypes.DOTNET_Core, ProjectTypes.ASPNET_5))
{
Dispatcher.CurrentDispatcher.BeginInvoke(new Action(() =>
{
var dtsItem = VSHelpers.GetProjectItem(dtsFile);
if (dtsItem != null)
{
dtsItem.Properties.Item("DependentUpon").Value = sourceItem.Name;
}
if (isEmptyEnum == false)
{
var dtsItem2 = VSHelpers.GetProjectItem(dtsEnumFile);
if (dtsItem2 != null)
{
dtsItem2.Properties.Item("DependentUpon").Value = sourceItem.Name;
}
}
Telemetry.TrackOperation("FileGenerated");
}), DispatcherPriority.ApplicationIdle, null);
}
else if (sourceItem.ContainingProject.IsKind(ProjectTypes.WEBSITE_PROJECT))
{
sourceItem.ContainingProject.ProjectItems.AddFromFile(dtsFile);
if (isEmptyEnum == false)
{
sourceItem.ContainingProject.ProjectItems.AddFromFile(dtsEnumFile);
}
}
// Also create the definition map data and add it to our project item
CreateDtsMapFile(sourceItem, definitionMapData);
}
public static string GetCopyDtsFileName(DefinitionMapData definitionMapData, ProjectItem projectItem, bool isEnumDefinition)
{
string sourceFile = string.IsNullOrWhiteSpace(definitionMapData.CustomName) ? projectItem.Name : definitionMapData.CustomName;
if (isEnumDefinition)
{
sourceFile += "Enum";
}
return(GenerationService.GenerateFileName(sourceFile));
}
private static bool HasIntellisense(ProjectItem projectItem, HashSet <string> references)
{
for (short i = 0; i < projectItem.FileCount; i++)
{
var fileName = GenerationService.GenerateFileName(projectItem.FileNames[i]);
references.Add(fileName);
return(true);
}
return(false);
}
private void FileActionOccurred(object sender, TextDocumentFileActionEventArgs e)
{
if (e.FileActionType != FileActionTypes.ContentSavedToDisk)
{
return;
}
_item = VSHelpers.GetProjectItem(e.FilePath);
Options.ReadOptionOverrides(_item, false);
string fileName = GenerationService.GenerateFileName(e.FilePath);
if (File.Exists(fileName))
{
DtsPackage.EnsurePackageLoad();
CreateDtsFile(_item);
}
}
public static void CreateDtsFile(ProjectItem sourceItem)
{
string sourceFile = sourceItem.FileNames[1];
string dtsFile = GenerationService.GenerateFileName(sourceFile);
var output = ConvertToTypeScript(sourceItem);
if (string.IsNullOrWhiteSpace(Options.NodeModulePath))
{
WriteTypescriptToFile(output, dtsFile, sourceItem);
}
else
{
string nodeModuleFile = Path.ChangeExtension(sourceFile, ".ts");
WriteTypescriptToFile(output, nodeModuleFile, sourceItem);
}
}
protected override byte[] GenerateCode(string inputFileName, string inputFileContent)
{
ProjectItem item = Dte.Solution.FindProjectItem(inputFileName);
OriginalExt = Path.GetExtension(inputFileName);
if (item != null)
{
try
{
Telemetry.TrackOperation("FileGenerated");
string output = GenerationService.ConvertToTypeScript(item);
if (!string.IsNullOrWhiteSpace(Options.NodeModulePath))
{
// generate a Node module instead of a d.ts file.
string outputFile = Path.ChangeExtension(inputFileName, ".ts");
string projectPath = Path.GetDirectoryName(item.ContainingProject.FileName);
outputFile = outputFile.Substring(projectPath.Length + 1); // strip the initial part of the path
outputFile = Path.Combine(projectPath, Options.NodeModulePath, outputFile);
var di = Directory.CreateDirectory(Path.GetDirectoryName(outputFile));
if (di != null && di.Exists)
{
VSHelpers.CheckFileOutOfSourceControl(outputFile);
File.WriteAllText(outputFile, output);
output = $"// Node module file generated at {MakeRelativePath(InputFilePath, outputFile)}";
}
}
return(Encoding.UTF8.GetBytes(output));
}
catch (Exception ex)
{
VSHelpers.WriteOnOutputWindow(string.Format("{0} - File Generation Failure", inputFileName));
VSHelpers.WriteOnOutputWindow(ex.StackTrace);
Telemetry.TrackOperation("FileGenerated", Microsoft.VisualStudio.Telemetry.TelemetryResult.Failure);
Telemetry.TrackException("FileGenerated", ex);
}
}
return(new byte[0]);
}
protected override byte[] GenerateCode(string inputFileName, string inputFileContent)
{
ProjectItem item = Dte.Solution.FindProjectItem(inputFileName);
this.originalExt = Path.GetExtension(inputFileName);
if (item != null)
{
try
{
// Get metadata from our project item
DefinitionMapData definitionMapData = VSHelpers.GetDefinitionMapData(item);
string dts = GenerationService.ConvertToTypeScriptWithoutEnums(item, ref definitionMapData, out bool isEmpty);
string dtsEnum = GenerationService.ConvertToTypeScriptEnumsOnly(item, ref definitionMapData, out bool isEmptyEnum);
Telemetry.TrackOperation("FileGenerated");
if (isEmpty == false)
{
// Copy our dts file to the specified paths in the definition map data
GenerationService.CopyDtsFile(definitionMapData, item, dts, false);
}
if (isEmptyEnum == false)
{
GenerationService.CopyDtsFile(definitionMapData, item, dtsEnum, true);
GenerationService.CreateEnumFile(item, dtsEnum);
}
// And in the last step write the map file which contains some metadata
GenerationService.CreateDtsMapFile(item, definitionMapData);
return(Encoding.UTF8.GetBytes(dts));
}
catch (Exception ex)
{
Telemetry.TrackOperation("FileGenerated", Microsoft.VisualStudio.Telemetry.TelemetryResult.Failure);
Telemetry.TrackException("FileGenerated", ex);
}
}
return(new byte[0]);
}
private void Execute(object sender, EventArgs e)
{
if (_item == null)
{
return;
}
Options.ReadOptionOverrides(_item, false);
// .NET Core and Website projects
if (_item.ContainingProject.IsKind(ProjectTypes.DOTNET_Core, ProjectTypes.ASPNET_5, ProjectTypes.WEBSITE_PROJECT))
{
string dtsFile = GenerationService.GenerateFileName(_item.FileNames[1]);
bool synOn = File.Exists(dtsFile);
if (synOn)
{
var dtsItem = VSHelpers.GetProjectItem(dtsFile);
dtsItem?.Delete();
File.Delete(dtsFile);
}
else
{
GenerationService.CreateDtsFile(_item);
}
}
// Legacy .NET projects
else
{
bool synOn = _item.Properties.Item("CustomTool").Value.ToString() == DtsGenerator.Name;
if (synOn)
{
_item.Properties.Item("CustomTool").Value = "";
Telemetry.TrackUserTask("EnableGeneration");
}
else
{
_item.Properties.Item("CustomTool").Value = DtsGenerator.Name;
Telemetry.TrackUserTask("DisabledGeneration");
}
}
}
private void BeforeQueryStatus(object sender, EventArgs e)
{
var button = (OleMenuCommand)sender;
button.Visible = button.Enabled = false;
if (_dte.SelectedItems.Count != 1)
{
return;
}
_item = _dte.SelectedItems?.Item(1)?.ProjectItem;
if (_item == null)
{
return;
}
Options.ReadOptionOverrides(_item, false);
if (_item == null || _item.ContainingProject == null || _item.FileCodeModel == null)
{
return;
}
var fileName = _item.FileNames[1];
var ext = Path.GetExtension(fileName);
if (Constants.SupportedSourceExtensions.Contains(ext, StringComparer.OrdinalIgnoreCase))
{
if (_item.ContainingProject.IsKind(ProjectTypes.DOTNET_Core, ProjectTypes.ASPNET_5, ProjectTypes.WEBSITE_PROJECT))
{
string dtsFile = GenerationService.GenerateFileName(_item.FileNames[1]);
button.Checked = File.Exists(dtsFile);
}
else
{
button.Checked = _item.Properties.Item("CustomTool").Value.ToString() == DtsGenerator.Name;
}
button.Visible = button.Enabled = true;
}
}
public static string WriteTypeScriptEnumsOnly(IEnumerable <IntellisenseObject> objects, ProjectItem sourceItem, out bool isEmpty)
{
isEmpty = true;
var sb = new StringBuilder();
foreach (var ns in objects.GroupBy(o => o.Namespace))
{
List <string> references = GetReferences(objects, sourceItem);
if (references.Count > 0)
{
foreach (string referencePath in references.OrderBy(p => Path.GetFileName(p)))
{
string path = Path.GetFileName(referencePath);
ProjectItem definitionMapProjectItem = sourceItem.DTE.Solution.FindProjectItem(referencePath);
if (definitionMapProjectItem != null)
{
DefinitionMapData definitionMapData = VSHelpers.GetDefinitionMapData(definitionMapProjectItem.Collection.Parent as ProjectItem);
if (definitionMapData != null)
{
if (string.IsNullOrWhiteSpace(definitionMapData.CustomName) == false)
{
path = GenerationService.GetCopyDtsFileName(definitionMapData, definitionMapProjectItem, true);
}
}
}
sb.AppendFormat("/// <reference path=\"{0}\" />\r\n", path);
}
sb.AppendLine();
}
if (!Options.GlobalScope)
{
sb.AppendFormat("declare module {0} {{\r\n", ns.Key);
}
foreach (IntellisenseObject io in ns)
{
if (io.IsEnum == false)
{
continue;
}
isEmpty = false;
if (!string.IsNullOrEmpty(io.Summary))
{
sb.AppendLine("\t/** " + _whitespaceTrimmer.Replace(io.Summary, "") + " */");
}
sb.AppendLine("\tenum " + Utility.CamelCaseClassName(io.Name) + " {");
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}");
}
if (!Options.GlobalScope)
{
sb.AppendLine("}");
}
}
return(sb.ToString());
}
public static string WriteTypeScriptWithoutEnums(IEnumerable <IntellisenseObject> objects, ProjectItem sourceItem, out bool isEmpty)
{
isEmpty = true;
var sb = new StringBuilder();
foreach (var ns in objects.GroupBy(o => o.Namespace))
{
List <string> references = GetReferences(objects, sourceItem);
if (references.Count > 0)
{
foreach (string referencePath in references.OrderBy(p => Path.GetFileName(p)))
{
string path = Path.GetFileName(referencePath);
ProjectItem definitionMapProjectItem = sourceItem.DTE.Solution.FindProjectItem(referencePath);
if (definitionMapProjectItem != null)
{
DefinitionMapData definitionMapData = VSHelpers.GetDefinitionMapData(definitionMapProjectItem.Collection.Parent as ProjectItem);
if (definitionMapData != null)
{
if (string.IsNullOrWhiteSpace(definitionMapData.CustomName) == false)
{
path = GenerationService.GetCopyDtsFileName(definitionMapData, definitionMapProjectItem, false);
}
}
}
sb.AppendFormat("/// <reference path=\"{0}\" />\r\n", path);
}
sb.AppendLine();
}
if (!Options.GlobalScope)
{
sb.AppendFormat("declare module {0} {{\r\n", ns.Key);
}
foreach (IntellisenseObject io in ns)
{
if (io.IsEnum)
{
continue;
}
isEmpty = false;
if (!string.IsNullOrEmpty(io.Summary))
{
sb.AppendLine("\t/** " + _whitespaceTrimmer.Replace(io.Summary, "") + " */");
}
string type = Options.ClassInsteadOfInterface ? "\tclass " : "\tinterface ";
sb.Append(type).Append(Utility.CamelCaseClassName(io.Name)).Append(" ");
if (!string.IsNullOrEmpty(io.BaseName))
{
sb.Append("extends ");
if (Options.GlobalScope == false)
{
sb.Append(ns.Key).Append(".");
}
if (!string.IsNullOrEmpty(io.BaseNamespace) && io.BaseNamespace != io.Namespace)
{
sb.Append(io.BaseNamespace).Append(".");
}
sb.Append(Utility.CamelCaseClassName(io.BaseName)).Append(" ");
}
WriteTSInterfaceDefinition(sb, "\t", io.Properties);
sb.AppendLine();
}
if (!Options.GlobalScope)
{
sb.AppendLine("}");
}
}
return(sb.ToString());
}
