/// <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(UgliflyResult 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);
}
/// <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(UgliflyResult 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));
}
public static void Minify(CompilerOptions options)
{
if (!options.Minify || !File.Exists(options.OutputFilePath))
{
return;
}
string cssContent = File.ReadAllText(options.OutputFilePath);
var settings = new CssSettings
{
ColorNames = CssColor.Strict,
CommentMode = CssComment.Important
};
UgliflyResult result = Uglify.Css(cssContent, settings);
if (result.HasErrors)
{
return;
}
string minFilePath = Path.ChangeExtension(options.OutputFilePath, ".min.css");
VsHelpers.CheckFileOutOfSourceControl(minFilePath);
File.WriteAllText(minFilePath, result.Code, new UTF8Encoding(true));
VsHelpers.AddNestedFile(options.OutputFilePath, minFilePath);
}
private static void MinifyHtml(Bundle bundle, MinificationResult minResult)
{
var settings = HtmlOptions.GetSettings(bundle);
UgliflyResult uglifyResult = Uglify.Html(bundle.Output, settings, minResult.FileName);
WriteMinFile(bundle, minResult, uglifyResult);
}
private static void MinifyCss(Bundle bundle, MinificationResult minResult)
{
var settings = CssOptions.GetSettings(bundle);
UgliflyResult uglifyResult = Uglify.Css(bundle.Output, minResult.FileName, settings);
WriteMinFile(bundle, minResult, uglifyResult);
}
/// <summary>
/// Produces a code minifiction of CSS content by using the NUglify CSS Minifier
/// </summary>
/// <param name="content">CSS 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));
}
CssSettings originalCssSettings = isInlineCode ?
_originalInlineCssSettings : _originalEmbeddedCssSettings;
UgliflyResult originalResult = Uglify.Css(content, originalCssSettings, _originalJsSettings);
CodeMinificationResult result = GetCodeMinificationResult(originalResult);
return(result);
}
internal static void AddAjaxminErrors(UgliflyResult 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);
}
}
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);
UgliflyResult result = outputFile.EndsWith(".css") ? Uglify.Css(input) : outputFile.EndsWith(".js") ? Uglify.Js(input) : default(UgliflyResult);
if (!result.HasErrors)
{
File.WriteAllText(PathManager.GetContentRootPath(requestHandler) + "\\" + outputFile, result.Code);
}
}
catch { }
}
private static void MinifyJavaScript(Bundle bundle, MinificationResult minResult)
{
var settings = JavaScriptOptions.GetSettings(bundle);
if (!bundle.SourceMap)
{
UgliflyResult uglifyResult = Uglify.Js(bundle.Output, settings);
WriteMinFile(bundle, minResult, uglifyResult);
}
else
{
string minFile = GetMinFileName(minResult.FileName);
string mapFile = minFile + ".map";
using (StringWriter writer = new StringWriter())
{
using (V3SourceMap sourceMap = new V3SourceMap(writer))
{
settings.SymbolsMap = sourceMap;
sourceMap.StartPackage(minFile, mapFile);
sourceMap.SourceRoot = bundle.SourceMapRootPath;
string file = minResult.FileName;
if (bundle.OutputIsMinFile)
{
var inputs = bundle.GetAbsoluteInputFiles();
if (inputs.Count == 1)
{
file = inputs[0];
}
}
UgliflyResult uglifyResult = Uglify.Js(bundle.Output, file, settings);
WriteMinFile(bundle, minResult, uglifyResult);
}
minResult.SourceMap = writer.ToString();
}
}
}
private static MinificationResult MinifyJavaScript(Bundle bundle)
{
string file = bundle.GetAbsoluteOutputFile();
var settings = JavaScriptOptions.GetSettings(bundle);
var result = new MinificationResult(file, null, null);
string minFile = GetMinFileName(file);
string mapFile = minFile + ".map";
try
{
if (!bundle.SourceMap)
{
UgliflyResult uglifyResult;
try
{
uglifyResult = Uglify.Js(ReadAllText(file), settings);
}
catch
{
uglifyResult = new UgliflyResult(null,
new List <UglifyError> {
new UglifyError
{
IsError = true,
File = file,
Message = "Error processing file"
}
});
}
result.MinifiedContent = uglifyResult.Code?.Trim();
if (!uglifyResult.HasErrors && !string.IsNullOrEmpty(result.MinifiedContent))
{
bool containsChanges = FileHelpers.HasFileContentChanged(minFile, result.MinifiedContent);
OnBeforeWritingMinFile(file, minFile, bundle, containsChanges);
result.Changed |= containsChanges;
if (containsChanges)
{
File.WriteAllText(minFile, result.MinifiedContent, new UTF8Encoding(false));
OnAfterWritingMinFile(file, minFile, bundle, containsChanges);
}
GzipFile(minFile, bundle, containsChanges);
}
else
{
AddAjaxminErrors(uglifyResult, result);
}
}
else
{
using (StringWriter writer = new StringWriter())
{
using (V3SourceMap sourceMap = new V3SourceMap(writer))
{
settings.SymbolsMap = sourceMap;
sourceMap.StartPackage(minFile, mapFile);
sourceMap.SourceRoot = bundle.SourceMapRootPath;
if (file.EndsWith(".min.js"))
{
var inputs = bundle.GetAbsoluteInputFiles();
if (inputs.Count == 1)
{
file = inputs[0];
}
}
UgliflyResult uglifyResult;
try
{
uglifyResult = Uglify.Js(ReadAllText(file), file, settings);
}
catch
{
uglifyResult = new UgliflyResult(null,
new List <UglifyError> {
new UglifyError
{
IsError = true,
File = file,
Message = "Error processing file"
}
});
}
result.MinifiedContent = uglifyResult.Code?.Trim();
if (!uglifyResult.HasErrors && !string.IsNullOrEmpty(result.MinifiedContent))
{
bool containsChanges = FileHelpers.HasFileContentChanged(minFile, result.MinifiedContent);
result.Changed |= containsChanges;
OnBeforeWritingMinFile(file, minFile, bundle, containsChanges);
if (containsChanges)
{
File.WriteAllText(minFile, result.MinifiedContent, new UTF8Encoding(false));
OnAfterWritingMinFile(file, minFile, bundle, containsChanges);
}
GzipFile(minFile, bundle, containsChanges);
}
else
{
AddAjaxminErrors(uglifyResult, result);
}
}
result.SourceMap = writer.ToString();
}
}
}
catch (Exception ex)
{
result.Errors.Add(new MinificationError
{
FileName = file,
Message = ex.Message,
LineNumber = 0,
ColumnNumber = 0
});
}
return(result);
}
private static MinificationResult MinifyHtml(Bundle bundle)
{
string file = bundle.GetAbsoluteOutputFile();
string content = ReadAllText(file);
var settings = HtmlOptions.GetSettings(bundle);
string minFile = GetMinFileName(file);
var minResult = new MinificationResult(file, null, null);
try
{
UgliflyResult uglifyResult;
try
{
uglifyResult = Uglify.Html(content, settings, file);
}
catch
{
uglifyResult = new UgliflyResult(null,
new List <UglifyError> {
new UglifyError
{
IsError = true,
File = file,
Message = "Error processing file"
}
});
}
minResult.MinifiedContent = uglifyResult.Code?.Trim();
if (!uglifyResult.HasErrors && !string.IsNullOrEmpty(minResult.MinifiedContent))
{
bool containsChanges = FileHelpers.HasFileContentChanged(minFile, minResult.MinifiedContent);
minResult.Changed |= containsChanges;
OnBeforeWritingMinFile(file, minFile, bundle, containsChanges);
if (containsChanges)
{
File.WriteAllText(minFile, minResult.MinifiedContent, new UTF8Encoding(false));
OnAfterWritingMinFile(file, minFile, bundle, containsChanges);
}
GzipFile(minFile, bundle, containsChanges);
}
else
{
foreach (var error in uglifyResult.Errors)
{
minResult.Errors.Add(new MinificationError
{
FileName = file,
Message = error.Message,
LineNumber = error.StartLine,
ColumnNumber = error.StartColumn
});
}
}
}
catch (Exception ex)
{
minResult.Errors.Add(new MinificationError
{
FileName = file,
Message = ex.Message,
LineNumber = 0,
ColumnNumber = 0
});
}
return(minResult);
}
private static void WriteMinFile(Bundle bundle, MinificationResult minResult, UgliflyResult 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)
{
File.WriteAllText(minFile, minResult.MinifiedContent, new UTF8Encoding(false));
OnAfterWritingMinFile(minResult.FileName, minFile, bundle, containsChanges);
}
}
else
{
AddNUglifyErrors(uglifyResult, minResult);
}
}
