private void MinifyJs(BundleContext context, BundleResponse response)
{
UglifyResult uglifyResult = new UglifyResult();
response.Content = new StringBuilder(10000);
foreach (BundleFile bundleFile in response.BundleFiles.Values)
{
try
{
uglifyResult = Uglify.Js(bundleFile.Content.ToString(), ConfigureSettings(new CodeSettings()));
if (uglifyResult.HasErrors)
{
AddErrors(uglifyResult, context, response, bundleFile.PhysicalPath);
}
response.Content.Append(uglifyResult.Code);
if (!string.IsNullOrEmpty(uglifyResult.Code) && uglifyResult.Code.Length > 1)
{
char last = uglifyResult.Code[uglifyResult.Code.Length - 1];
if (!last.Equals('}') && !last.Equals(';'))
{
response.Content.Append(";");
AddErrors($"Javascript file is missing trailing ';'", $"Control and fix the missing ';'!", context, response, bundleFile.PhysicalPath);
}
}
}
catch (Exception ex)
{
AddErrors(ex.Message, ex.StackTrace, context, response, bundleFile.PhysicalPath);
response.Content.Append(bundleFile.Content);//in case of an error append the non minified
}
}
response.Content.Append(response.ContentRaw);
}
protected void SetIdentifier(UglifyResult min)
{
SHA256 sha256 = SHA256.Create();
var hashResult = sha256.ComputeHash(Encoding.Unicode.GetBytes(min.Code));
this.VersionIdentifier = Convert.ToBase64String(hashResult);
}
private void ExecuteCruncher(ITaskItem scriptItem)
{
string script = File.ReadAllText(scriptItem.ItemSpec);
CodeSettings codeSettings = new CodeSettings
{
StripDebugStatements = false,
OutputMode = OutputMode.SingleLine,
IgnorePreprocessorDefines = true,
IgnoreConditionalCompilation = true,
TermSemicolons = true,
NoAutoRenameList = "$"
};
UglifyResult result = Uglify.Js(script, codeSettings);
if (result.HasErrors)
{
foreach (UglifyError error in result.Errors)
{
Log.LogError(error.Subcategory, error.ErrorCode, error.HelpKeyword, error.File, error.StartLine, error.StartColumn, error.EndLine, error.EndColumn, error.Message);
}
return;
}
File.WriteAllText(scriptItem.ItemSpec, result.Code);
}
public override Task ExecuteAsync(IAssetContext config)
{
var content = new Dictionary <string, byte[]>();
foreach (string key in config.Content.Keys)
{
if (key.EndsWith(".min.js"))
{
continue;
}
string input = config.Content[key].AsString();
UglifyResult result = Uglify.Js(input, Settings);
string minified = result.Code;
if (result.HasErrors)
{
minified = $"/* {string.Join("\r\n", result.Errors)} */\r\n" + input;
}
content[key] = minified.AsByteArray();
}
config.Content = content;
return(Task.CompletedTask);
}
public StringBuilder Process(StringBuilder inputHtml, ILogger logger, BundleResponse response)
{
StringBuilder sb = new StringBuilder(1000);
UglifyResult uglifyResult = new UglifyResult();
try
{
uglifyResult = Uglify.Html(inputHtml.ToString(), ConfigureSettings(new HtmlSettings()));
if (uglifyResult.HasErrors)
{
foreach (UglifyError error in uglifyResult.Errors)
{
if (response != null)
{
response.TransformationErrors.Append($"Error message: {error.Message}<br />Error details: {error.ToString()}").Append("<br />");
}
logger.LogCritical($"Error message: {error.Message} {Environment.NewLine} Error details: {error.ToString()}", error);
}
}
sb.Append(uglifyResult.Code);
}
catch (Exception ex)
{
response.TransformationErrors.Append($"Error: {ex.Message}<br />Error details: {ex.StackTrace}").Append("<br />");
logger.LogCritical($"Error: {ex.Message} {Environment.NewLine} Error details: {ex.StackTrace}", ex);
throw;
}
return(sb);
}
public override async Task <IEnumerable <Asset> > TransformAsync(string extension, params Asset[] assets)
{
CodeSettings codeSettings = new CodeSettings()
{
AmdSupport = true,
ScriptVersion = ScriptVersion.None,
PreserveImportantComments = false
};
List <Asset> outputs = new List <Asset>();
foreach (var asset in assets)
{
string code = await asset.ReadContentAsStringAsync();
UglifyResult uglifyResult = Uglify.Js(code, codeSettings);
if (uglifyResult.HasErrors)
{
throw new AggregateException(uglifyResult.Errors.Select(x => new Exception(x.Message)));
}
Asset outputAsset = await asset.CloneWithContentAsync(uglifyResult.Code);
outputs.Add(outputAsset);
}
return(outputs.AsEnumerable());
}
/// <summary>
/// Gets a code minification result from original minification result
/// </summary>
/// <param name="originalResult">Original minification result</param>
/// <returns>Code minification result</returns>
protected static CodeMinificationResult GetCodeMinificationResult(UglifyResult originalResult)
{
var errors = new List <MinificationErrorInfo>();
var warnings = new List <MinificationErrorInfo>();
if (originalResult.HasErrors)
{
IList <UglifyError> originalErrors = originalResult.Errors;
foreach (UglifyError originalError in originalErrors)
{
var errorDetails = new MinificationErrorInfo(originalError.Message, originalError.StartLine,
originalError.StartColumn, string.Empty);
if (originalError.IsError)
{
errors.Add(errorDetails);
}
else
{
warnings.Add(errorDetails);
}
}
}
return(new CodeMinificationResult(originalResult.Code, errors, warnings));
}
protected override byte[] GenerateCode(string inputFileName, string inputFileContent)
{
var options = new ScssOptions();
ScssResult result = Scss.ConvertFileToCss(inputFileName, options);
UglifyResult minified = Uglify.Css(result.Css);
return(Encoding.UTF8.GetBytes(minified.Code));
}
public async Task <string> GetStyle()
{
string path = $"{environment.WebRootPath}{Path.DirectorySeparatorChar}style.css";
string css = await File.ReadAllTextAsync(path);
UglifyResult result = Uglify.Css(css);
return(result.Code);
}
private static void CheckErrors(UglifyResult result)
{
if (result.HasErrors)
{
throw new NUglifyException(
$"There are some errors on uglifying the given source code!{Environment.NewLine}{result.Errors.Select(err => err.ToString()).JoinAsString(Environment.NewLine)}",
result.Errors
);
}
}
private void AddErrors(UglifyResult uglifyResult, BundleContext context, BundleResponse response, string file)
{
if (uglifyResult.HasErrors)
{
foreach (UglifyError error in uglifyResult.Errors)
{
AddErrors(error.Message, error.ToString(), context, response, file);
}
}
}
/// <summary>
/// Produces a code minifiction of JS content by using the NUglify JS Minifier
/// </summary>
/// <param name="content">JS content</param>
/// <param name="isInlineCode">Flag whether the content is inline code</param>
/// <param name="encoding">Text encoding</param>
/// <returns>Minification result</returns>
public CodeMinificationResult Minify(string content, bool isInlineCode, Encoding encoding)
{
if (string.IsNullOrWhiteSpace(content))
{
return(new CodeMinificationResult(string.Empty));
}
CodeSettings originalJsSettings = isInlineCode ?
_originalInlineJsSettings : _originalEmbeddedJsSettings;
UglifyResult originalResult = Uglify.Js(content, originalJsSettings);
CodeMinificationResult result = GetCodeMinificationResult(originalResult);
return(result);
}
protected override byte[] GenerateCode(string inputFileName, string inputFileContent)
{
string ext = Path.GetExtension(inputFileName).ToLowerInvariant();
UglifyResult result = Minify(inputFileName, inputFileContent);
if (result.HasErrors)
{
return(Encoding.UTF8.GetBytes("// Source file contains errors"));
}
else
{
return(Encoding.UTF8.GetBytes(result.Code));
}
}
private static void AddNUglifyErrors(UglifyResult minifier, MinificationResult minResult)
{
foreach (var error in minifier.Errors)
{
var minError = new MinificationError
{
FileName = minResult.FileName,
Message = error.Message,
LineNumber = error.StartLine,
ColumnNumber = error.StartColumn
};
minResult.Errors.Add(minError);
}
}
private static void CheckErrors(UglifyResult result, string originalFileName)
{
if (result.HasErrors)
{
var errorMessage = "There are some errors on uglifying the given source code!";
if (originalFileName != null)
{
errorMessage += " Original file: " + originalFileName;
}
throw new NUglifyException(
$"{errorMessage}{Environment.NewLine}{result.Errors.Select(err => err.ToString()).JoinAsString(Environment.NewLine)}",
result.Errors
);
}
}
public static void RebuildBundle(IRequestHandler requestHandler, string bundleFilename)
{
try
{
dynamic bundle = JsonConvert.DeserializeObject(File.ReadAllText(PathManager.GetBundlePath(requestHandler, bundleFilename)));
string outputFile = bundle.outputFile;
IEnumerable <string> inputFiles = bundle.inputFiles.ToObject <IEnumerable <string> >();
string input = BandleManager.ConcatFiles(requestHandler, inputFiles);
UglifyResult result = outputFile.EndsWith(".css") ? Uglify.Css(input) : outputFile.EndsWith(".js") ? Uglify.Js(input) : default(UglifyResult);
if (!result.HasErrors)
{
File.WriteAllText(Path.Combine(PathManager.GetContentRootPath(requestHandler), outputFile), result.Code);
}
}
catch { }
}
public override async Task <IEnumerable <Asset> > TransformAsync(string extension, params Asset[] assets)
{
CssSettings cssSettings = new CssSettings()
{
CommentMode = CssComment.None
};
if (0 < this.MinificationOptions.Substitutions.Count)
{
cssSettings.ReplacementTokensApplyDefaults(this.MinificationOptions.Substitutions);
}
CodeSettings codeSettings = new CodeSettings()
{
AmdSupport = true,
ScriptVersion = ScriptVersion.None,
PreserveImportantComments = false
};
List <Asset> outputs = new List <Asset>();
foreach (var asset in assets)
{
string code = await asset.ReadContentAsStringAsync();
UglifyResult uglifyResult = Uglify.Css(code, cssSettings, codeSettings);
if (uglifyResult.HasErrors)
{
throw new AggregateException(uglifyResult.Errors.Select(x => new Exception(x.Message)));
}
Asset outputAsset = await asset.CloneWithContentAsync(uglifyResult.Code);
outputs.Add(outputAsset);
}
return(outputs.AsEnumerable());
}
private async System.Threading.Tasks.Task TranspileAsync(string filePath)
{
await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();
DTE2 dte = await AsyncServiceProvider.GlobalProvider.GetServiceAsync <DTE, DTE2>();
var options = new ScssOptions();
options.IncludePaths.Add(Path.GetDirectoryName(filePath));
ScssResult result = Scss.ConvertToCss(_doc.TextBuffer.CurrentSnapshot.GetText(), options);
var cssPath = Path.ChangeExtension(filePath, ".css");
dte.SourceControl.CheckOutItemSafely(cssPath);
using (var writer = new StreamWriter(cssPath))
{
await writer.WriteAsync(result.Css);
}
ProjectItem scssItem = dte.Solution.FindProjectItem(filePath);
ProjectItem cssItem = dte.Solution.FindProjectItem(cssPath);
if (cssItem != null || scssItem.TryAddNestedFile(cssPath, out cssItem))
{
UglifyResult minified = Uglify.Css(result.Css);
var minPath = Path.ChangeExtension(cssPath, ".min.css");
dte.SourceControl.CheckOutItemSafely(minPath);
using (var writer = new StreamWriter(minPath))
{
await writer.WriteAsync(minified.Code);
}
cssItem.TryAddNestedFile(minPath, out _);
}
}
private void MinifyCss(BundleContext context, BundleResponse response)
{
UglifyResult uglifyResult = new UglifyResult();
response.Content = new StringBuilder(10000);
foreach (BundleFile bundleFile in response.BundleFiles.Values)
{
try
{
uglifyResult = Uglify.Css(bundleFile.Content.ToString(), ConfigureSettings(new CssSettings()));
if (uglifyResult.HasErrors)
{
AddErrors(uglifyResult, context, response, bundleFile.PhysicalPath);
}
response.Content.Append(uglifyResult.Code);
}
catch (Exception ex)
{
AddErrors(ex.Message, ex.StackTrace, context, response, bundleFile.PhysicalPath);
response.Content.Append(bundleFile.Content);//in case of an error append the non minified
}
}
}
public string Process(string content, string filePath)
{
UglifyResult result = Uglify.Css(content, _settings);
if (result.Errors.Count > 0)
{
var message =
result.HasErrors ?
$"Css minification of '{{FILEPATH}}' failed:{Environment.NewLine}{{REASON}}" :
$"Css minification of '{{FILEPATH}}' completed with warnings:{Environment.NewLine}{{REASON}}";
_logger.LogWarning(message,
filePath ?? "(content)",
string.Join(Environment.NewLine, result.Errors));
if (result.HasErrors)
{
return(content);
}
}
return(result.Code);
}
public void Prepare()
{
var fullContent = string.Empty;
foreach (var item in this.Pathes)
{
if (!File.Exists(item.Value) && BundleCollection.Instance.DontThrowOnMissingFile)
{
continue;
}
var fContent = File.ReadAllText(item.Value);
fContent = Relocate(fContent, item.Key);
fullContent += fContent;
}
this.minResult = MinFunc.Invoke(fullContent);
var outPath = Path.Combine(BundleCollection.Instance.RootPath, this.BundlePath.Replace("~/", string.Empty));
File.WriteAllText(outPath, minResult.Code);
SetIdentifier(minResult);
}
/// <summary>
/// Executes the processor on the specified configuration.
/// </summary>
public Task ExecuteAsync(IAssetContext context)
{
var content = new Dictionary <string, byte[]>();
var env = (IHostingEnvironment)context.HttpContext.RequestServices.GetService(typeof(IHostingEnvironment));
IFileProvider fileProvider = context.Asset.GetFileProvider(env);
var builder = new StringBuilder();
// Javascript module for Angular that uses templateCache
builder.AppendFormat(@"angular.module('{0}',[]).run(['$templateCache',function($templateCache){{",
_moduleName);
foreach (string route in context.Content.Keys)
{
IFileInfo file = fileProvider.GetFileInfo(route);
string inputFile = file.PhysicalPath;
string input = context.Content[route].AsString().Replace("\r\n", "").Replace("'", "\\'");
UglifyResult result = Uglify.Html(input, Settings);
string minified = result.Code;
if (result.HasErrors)
{
minified = $"// {string.Join("\r\n", result.Errors)} ${input}";
}
builder.AppendFormat(@"$templateCache.put('{0}{1}','{2}');", _path, file.Name, minified);
//content[route] = cx.AsByteArray();
}
builder.Append(@"}]);");
string cx = builder.ToString();
content.Add(Guid.NewGuid().ToString(), cx.AsByteArray());
context.Content = content;
return(Task.CompletedTask);
}
private static void WriteMinFile(Bundle bundle, MinificationResult minResult, UglifyResult uglifyResult)
{
var minFile = GetMinFileName(minResult.FileName);
minResult.MinifiedContent = uglifyResult.Code?.Trim();
if (!uglifyResult.HasErrors)
{
bool containsChanges = FileHelpers.HasFileContentChanged(minFile, minResult.MinifiedContent);
minResult.Changed |= containsChanges;
OnBeforeWritingMinFile(minResult.FileName, minFile, bundle, containsChanges);
if (containsChanges)
{
Directory.CreateDirectory(Path.GetDirectoryName(minFile));
File.WriteAllText(minFile, minResult.MinifiedContent, new UTF8Encoding(false));
OnAfterWritingMinFile(minResult.FileName, minFile, bundle, containsChanges);
}
}
else
{
AddNUglifyErrors(uglifyResult, minResult);
}
}
public override string Compress(string source)
{
UglifyResult ugly = Uglify.Js(source);
return(ProcessCompress(ugly));
}
private static string GenerateMinifierErrorsContent(string contentConcatedString, UglifyResult result)
{
var sbContent = new StringBuilder();
sbContent.Append("/* ");
sbContent.Append("An error occurred during minification, see errors below - returning concatenated content unminified.").Append("\r\n");
foreach (var error in result.Errors)
{
sbContent.Append(error).Append("\r\n");
}
sbContent.Append(" */\r\n");
sbContent.Append(contentConcatedString);
return(sbContent.ToString());
}
