public static void ProcessCompilerResults(MinificationResult result)
{
BundlerMinifierPackage._dispatcher.BeginInvoke(new Action(() =>
{
//if (result == null)
//{
// MessageBox.Show($"There is an error in the {FileHelpers.FILENAME} file. This could be due to a change in the format after this extension was updated.", "Web Compiler", MessageBoxButtons.OK, MessageBoxIcon.Information);
// if (File.Exists(configFile))
// BundlerMinifierPackage._dte.ItemOperations.OpenFile(configFile);
// return;
//}
if (result.HasErrors)
{
ErrorList.AddErrors(result.FileName, result.Errors);
}
else
{
ErrorList.CleanErrors(result.FileName);
BundlerMinifierPackage._dte.StatusBar.Text = $"{Path.GetFileName(result.FileName)} minified";
}
}), DispatcherPriority.ApplicationIdle, null);
}
public static MinificationResult MinifyBundle(Bundle bundle)
{
string file = bundle.OutputFileName;
string extension = Path.GetExtension(file).ToUpperInvariant();
MinificationResult result = null;
switch (extension)
{
case ".JS":
result = MinifyJavaScript(bundle);
break;
case ".CSS":
result = MinifyCss(bundle);
break;
case ".HTML":
case ".HTM":
result = MinifyHtml(bundle);
break;
}
if (result != null && result.HasErrors)
{
OnErrorMinifyingFile(result);
}
return(result);
}
private static void MinifyCss(Bundle bundle, MinificationResult minResult)
{
var settings = CssOptions.GetSettings(bundle);
var uglifyResult = Uglify.Css(bundle.Output, minResult.FileName, settings);
WriteMinFile(bundle, minResult, uglifyResult);
}
private static void MinifyHtml(Bundle bundle, MinificationResult minResult)
{
var settings = HtmlOptions.GetSettings(bundle);
var uglifyResult = Uglify.Html(bundle.Output, settings, minResult.FileName);
WriteMinFile(bundle, minResult, uglifyResult);
}
private static MinificationResult MinifyHtml(string file, bool produceGzipFile)
{
var settings = new HtmlMinificationSettings
{
RemoveOptionalEndTags = false,
AttributeQuotesRemovalMode = WebMarkupMin.Core.HtmlAttributeQuotesRemovalMode.Html5,
RemoveRedundantAttributes = false,
};
string content = File.ReadAllText(file);
string minFile = GetMinFileName(file);
var minifier = new HtmlMinifier(settings);
var minResult = new MinificationResult(file, null, null);
try
{
MarkupMinificationResult result = minifier.Minify(content, generateStatistics: true);
minResult.MinifiedContent = result.MinifiedContent;
if (!result.Errors.Any())
{
OnBeforeWritingMinFile(file, minFile);
File.WriteAllText(minFile, result.MinifiedContent, new UTF8Encoding(true));
OnAfterWritingMinFile(file, minFile);
if (produceGzipFile)
{
GzipFile(minFile);
}
}
else
{
foreach (var error in result.Errors)
{
minResult.Errors.Add(new MinificationError
{
FileName = file,
Message = error.Message,
LineNumber = error.LineNumber,
ColumnNumber = error.ColumnNumber
});
}
}
}
catch (Exception ex)
{
minResult.Errors.Add(new MinificationError
{
FileName = file,
Message = ex.Message,
LineNumber = 0,
ColumnNumber = 0
});
}
return(minResult);
}
private static MinificationResult MinifyHtml(Bundle bundle)
{
string file = bundle.GetAbsoluteOutputFile();
string content = ReadAllText(file);
var settings = HtmlOptions.GetSettings(bundle);
string minFile = GetMinFileName(file);
var minifier = new HtmlMinifier(settings);
var minResult = new MinificationResult(file, null, null);
try
{
MarkupMinificationResult result = minifier.Minify(content, generateStatistics: true);
minResult.MinifiedContent = result.MinifiedContent.Trim();
if (!result.Errors.Any())
{
bool containsChanges = FileHelpers.HasFileContentChanged(minFile, result.MinifiedContent);
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
{
foreach (var error in result.Errors)
{
minResult.Errors.Add(new MinificationError
{
FileName = file,
Message = error.Message,
LineNumber = error.LineNumber,
ColumnNumber = error.ColumnNumber
});
}
}
}
catch (Exception ex)
{
minResult.Errors.Add(new MinificationError
{
FileName = file,
Message = ex.Message,
LineNumber = 0,
ColumnNumber = 0
});
}
return(minResult);
}
private static void AddGenericException(MinificationResult minResult, Exception ex)
{
minResult.Errors.Add(new MinificationError
{
FileName = minResult.FileName,
Message = ex.Message,
LineNumber = 0,
ColumnNumber = 0
});
}
public static void OnErrorMinifyingFile(MinificationResult result)
{
if (ErrorMinifyingFile != null)
{
var e = new MinifyFileEventArgs(result.FileName, null, null, false);
e.Result = result;
ErrorMinifyingFile(null, e);
}
}
internal static void AddAjaxminErrors(Minifier minifier, MinificationResult minResult)
{
foreach (var error in minifier.ErrorList)
{
var minError = new MinificationError
{
FileName = minResult.FileName,
Message = error.Message,
LineNumber = error.StartLine,
ColumnNumber = error.StartColumn
};
minResult.Errors.Add(minError);
}
}
internal static void AddAjaxminErrors(Minifier minifier, MinificationResult minResult)
{
foreach (var error in minifier.ErrorList)
{
var minError = new MinificationError
{
FileName = minResult.FileName,
Message = error.Message,
LineNumber = error.StartLine,
ColumnNumber = error.StartColumn
};
minResult.Errors.Add(minError);
}
}
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 MinificationResult MinifyCss(Bundle bundle)
{
string file = bundle.GetAbsoluteOutputFile();
string content = ReadAllText(file);
var settings = CssOptions.GetSettings(bundle);
string minFile = GetMinFileName(file);
var minifier = new Minifier();
var result = new MinificationResult(file, null, null);
try
{
result.MinifiedContent = minifier.MinifyStyleSheet(content, settings).Trim();
if (!minifier.Errors.Any())
{
bool containsChanges = FileHelpers.HasFileContentChanged(minFile, result.MinifiedContent);
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(minifier, result);
}
}
catch (Exception ex)
{
result.Errors.Add(new MinificationError
{
FileName = file,
Message = ex.Message,
LineNumber = 0,
ColumnNumber = 0
});
}
return(result);
}
public static MinificationResult MinifyBundle(Bundle bundle)
{
string file = bundle.GetAbsoluteOutputFile();
string extension = Path.GetExtension(file).ToUpperInvariant();
var minResult = new MinificationResult(file, null, null);
if (!string.IsNullOrEmpty(bundle.Output) && bundle.IsMinificationEnabled)
{
try
{
switch (extension)
{
case ".JS":
MinifyJavaScript(bundle, minResult);
break;
case ".CSS":
MinifyCss(bundle, minResult);
break;
case ".HTML":
case ".HTM":
MinifyHtml(bundle, minResult);
break;
}
}
catch (Exception ex)
{
AddGenericException(minResult, ex);
}
}
if (minResult.HasErrors)
{
OnErrorMinifyingFile(minResult);
}
else if (bundle.IsGzipEnabled)
{
string minFile = bundle.IsMinificationEnabled
? GetMinFileName(bundle.GetAbsoluteOutputFile(), bundle.IsDebugMinificationEnabled)
: bundle.GetAbsoluteOutputFile();
GzipFile(minFile, bundle, minResult);
}
return(minResult);
}
private static MinificationResult MinifyCss(string file, bool produceGzipFile)
{
string content = File.ReadAllText(file);
string minFile = GetMinFileName(file);
var settings = new CssSettings()
{
CommentMode = CssComment.Hacks
};
var minifier = new Minifier();
var result = new MinificationResult(file, null, null);
try
{
result.MinifiedContent = minifier.MinifyStyleSheet(content, settings);
if (!minifier.Errors.Any())
{
OnBeforeWritingMinFile(file, minFile);
File.WriteAllText(minFile, result.MinifiedContent, new UTF8Encoding(true));
OnAfterWritingMinFile(file, minFile);
if (produceGzipFile)
{
GzipFile(minFile);
}
}
else
{
AddAjaxminErrors(minifier, result);
}
}
catch (Exception ex)
{
result.Errors.Add(new MinificationError
{
FileName = file,
Message = ex.Message,
LineNumber = 0,
ColumnNumber = 0
});
}
return(result);
}
private static void MinifyJavaScript(Bundle bundle, MinificationResult minResult)
{
var settings = JavaScriptOptions.GetSettings(bundle);
if (!bundle.SourceMap)
{
var 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];
}
}
var uglifyResult = Uglify.Js(bundle.Output, file, settings);
WriteMinFile(bundle, minResult, uglifyResult);
}
minResult.SourceMap = writer.ToString();
}
}
}
private static void GzipFile(string sourceFile, Bundle bundle, MinificationResult result)
{
var gzipFile = sourceFile + ".gz";
var containsChanges = result.Changed || File.GetLastWriteTimeUtc(gzipFile) < File.GetLastWriteTimeUtc(sourceFile);
OnBeforeWritingGzipFile(sourceFile, gzipFile, bundle, containsChanges);
if (containsChanges)
{
byte[] buffer = Encoding.UTF8.GetBytes(result.MinifiedContent ?? bundle.Output);
using (var fileStream = File.OpenWrite(gzipFile))
using (var gzipStream = new GZipStream(fileStream, CompressionLevel.Optimal))
{
gzipStream.Write(buffer, 0, buffer.Length);
}
OnAfterWritingGzipFile(sourceFile, gzipFile, bundle, containsChanges);
}
}
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)
{
File.WriteAllText(minFile, minResult.MinifiedContent, new UTF8Encoding(false));
OnAfterWritingMinFile(minResult.FileName, minFile, bundle, containsChanges);
}
}
else
{
AddNUglifyErrors(uglifyResult, minResult);
}
}
private bool ProcessBundle(string baseFolder, Bundle bundle)
{
OnProcessing(bundle, baseFolder);
var inputs = bundle.GetAbsoluteInputFiles();
bool changed = false;
if (bundle.GetAbsoluteInputFiles(true).Count > 1 || bundle.InputFiles.FirstOrDefault() != bundle.OutputFileName)
{
BundleHandler.ProcessBundle(baseFolder, bundle);
if (!bundle.IsMinificationEnabled || !bundle.OutputIsMinFile)
{
string outputFile = bundle.GetAbsoluteOutputFile();
bool containsChanges = FileHelpers.HasFileContentChanged(outputFile, bundle.Output);
if (containsChanges)
{
OnBeforeBundling(bundle, baseFolder, containsChanges);
DirectoryInfo outputFileDirectory = Directory.GetParent(outputFile);
outputFileDirectory.Create();
File.WriteAllText(outputFile, bundle.Output, new UTF8Encoding(false));
OnAfterBundling(bundle, baseFolder, containsChanges);
changed = true;
}
}
}
MinificationResult minResult = null;
var minFile = BundleMinifier.GetMinFileName(bundle.GetAbsoluteOutputFile());
if (bundle.IsMinificationEnabled)
{
var outputWriteTime = File.GetLastWriteTimeUtc(minFile);
var minifyChanged = bundle.MostRecentWrite >= outputWriteTime;
if (minifyChanged)
{
minResult = BundleMinifier.MinifyBundle(bundle);
// If no change is detected, then the minFile is not modified, so we need to update the write time manually
if (!minResult.Changed && File.Exists(minFile))
{
File.SetLastWriteTimeUtc(minFile, DateTime.UtcNow);
}
changed |= minResult.Changed;
if (bundle.SourceMap && !string.IsNullOrEmpty(minResult.SourceMap))
{
string mapFile = minFile + ".map";
bool smChanges = FileHelpers.HasFileContentChanged(mapFile, minResult.SourceMap);
if (smChanges)
{
OnBeforeWritingSourceMap(minFile, mapFile, smChanges);
File.WriteAllText(mapFile, minResult.SourceMap, new UTF8Encoding(false));
OnAfterWritingSourceMap(minFile, mapFile, smChanges);
changed = true;
}
}
}
else
{
OnMinificationSkipped(bundle, baseFolder, false);
}
}
if (bundle.IsGzipEnabled)
{
var fileToGzip = bundle.IsMinificationEnabled ?
minFile : bundle.GetAbsoluteOutputFile();
if (minResult == null)
{
BundleMinifier.GzipFile(fileToGzip, bundle, false, File.ReadAllText(fileToGzip));
}
else
{
BundleMinifier.GzipFile(fileToGzip, bundle, minResult.Changed, minResult.MinifiedContent);
}
}
return(changed);
}
protected static void OnErrorMinifyingFile(MinificationResult result)
{
if (ErrorMinifyingFile != null)
{
var e = new MinifyFileEventArgs(result.FileName, null, null);
e.Result = result;
ErrorMinifyingFile(null, e);
}
}
private static MinificationResult MinifyJavaScript(Bundle bundle)
{
string file = bundle.GetAbsoluteOutputFile();
var settings = JavaScriptOptions.GetSettings(bundle);
var minifier = new Minifier();
var result = new MinificationResult(file, null, null);
string minFile = GetMinFileName(file);
string mapFile = minFile + ".map";
try
{
if (!bundle.SourceMaps)
{
result.MinifiedContent = minifier.MinifyJavaScript(File.ReadAllText(file), settings);
if (!minifier.Errors.Any())
{
OnBeforeWritingMinFile(file, minFile, bundle);
File.WriteAllText(minFile, result.MinifiedContent, new UTF8Encoding(true));
OnAfterWritingMinFile(file, minFile, bundle);
}
else
{
FileMinifier.AddAjaxminErrors(minifier, result);
}
}
else
{
using (StringWriter writer = new StringWriter())
{
using (V3SourceMap sourceMap = new V3SourceMap(writer))
{
settings.SymbolsMap = sourceMap;
sourceMap.StartPackage(minFile, mapFile);
minifier.FileName = file;
result.MinifiedContent = minifier.MinifyJavaScript(File.ReadAllText(file), settings);
if (!minifier.Errors.Any())
{
OnBeforeWritingMinFile(file, minFile, bundle);
File.WriteAllText(minFile, result.MinifiedContent, new UTF8Encoding(true));
OnAfterWritingMinFile(file, minFile, bundle);
}
else
{
FileMinifier.AddAjaxminErrors(minifier, result);
}
}
result.SourceMap = writer.ToString();
}
}
GzipFile(minFile, bundle);
}
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 = File.ReadAllText(file);
var settings = HtmlOptions.GetSettings(bundle);
string minFile = GetMinFileName(file);
var minifier = new HtmlMinifier(settings);
var minResult = new MinificationResult(file, null, null);
try
{
MarkupMinificationResult result = minifier.Minify(content, generateStatistics: true);
minResult.MinifiedContent = result.MinifiedContent;
if (!result.Errors.Any())
{
OnBeforeWritingMinFile(file, minFile, bundle);
File.WriteAllText(minFile, result.MinifiedContent, new UTF8Encoding(true));
OnAfterWritingMinFile(file, minFile, bundle);
GzipFile(minFile, bundle);
}
else
{
foreach (var error in result.Errors)
{
minResult.Errors.Add(new MinificationError
{
FileName = file,
Message = error.Message,
LineNumber = error.LineNumber,
ColumnNumber = error.ColumnNumber
});
}
}
}
catch (Exception ex)
{
minResult.Errors.Add(new MinificationError
{
FileName = file,
Message = ex.Message,
LineNumber = 0,
ColumnNumber = 0
});
}
return minResult;
}
private static MinificationResult MinifyCss(Bundle bundle)
{
string file = bundle.GetAbsoluteOutputFile();
string content = File.ReadAllText(file);
var settings = CssOptions.GetSettings(bundle);
string minFile = GetMinFileName(file);
var minifier = new Minifier();
var result = new MinificationResult(file, null, null);
try
{
result.MinifiedContent = minifier.MinifyStyleSheet(content, settings);
if (!minifier.Errors.Any())
{
OnBeforeWritingMinFile(file, minFile, bundle);
File.WriteAllText(minFile, result.MinifiedContent, new UTF8Encoding(true));
OnAfterWritingMinFile(file, minFile, bundle);
GzipFile(minFile, bundle);
}
else
{
FileMinifier.AddAjaxminErrors(minifier, result);
}
}
catch (Exception ex)
{
result.Errors.Add(new MinificationError
{
FileName = file,
Message = ex.Message,
LineNumber = 0,
ColumnNumber = 0
});
}
return result;
}
private static MinificationResult MinifyJavaScript(Bundle bundle)
{
string file = bundle.GetAbsoluteOutputFile();
var settings = JavaScriptOptions.GetSettings(bundle);
var minifier = new Minifier();
var result = new MinificationResult(file, null, null);
string minFile = GetMinFileName(file);
string mapFile = minFile + ".map";
try
{
if (!bundle.SourceMap)
{
result.MinifiedContent = minifier.MinifyJavaScript(ReadAllText(file), settings).Trim();
if (!minifier.Errors.Any())
{
bool containsChanges = FileHelpers.HasFileContentChanged(minFile, result.MinifiedContent);
OnBeforeWritingMinFile(file, minFile, bundle, containsChanges);
if (containsChanges)
{
File.WriteAllText(minFile, result.MinifiedContent, new UTF8Encoding(false));
}
GzipFile(minFile, bundle, containsChanges);
OnAfterWritingMinFile(file, minFile, bundle, containsChanges);
}
else
{
AddAjaxminErrors(minifier, result);
}
}
else
{
using (StringWriter writer = new StringWriter())
{
using (V3SourceMap sourceMap = new V3SourceMap(writer))
{
settings.SymbolsMap = sourceMap;
sourceMap.StartPackage(minFile, mapFile);
minifier.FileName = file;
result.MinifiedContent = minifier.MinifyJavaScript(ReadAllText(file), settings).Trim();
if (!minifier.Errors.Any())
{
bool containsChanges = FileHelpers.HasFileContentChanged(minFile, result.MinifiedContent);
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(minifier, 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 MinifyJavaScript(string file, bool produceGzipFile, bool produceSourceMap)
{
var settings = new CodeSettings()
{
EvalTreatment = EvalTreatment.Ignore,
TermSemicolons = true,
PreserveImportantComments = false,
};
var minifier = new Minifier();
var result = new MinificationResult(file, null, null);
string minFile = GetMinFileName(file);
string mapFile = minFile + ".map";
try
{
if (!produceSourceMap)
{
result.MinifiedContent = minifier.MinifyJavaScript(File.ReadAllText(file), settings);
if (!minifier.Errors.Any())
{
OnBeforeWritingMinFile(file, minFile);
File.WriteAllText(minFile, result.MinifiedContent, new UTF8Encoding(true));
OnAfterWritingMinFile(file, minFile);
}
else
{
AddAjaxminErrors(minifier, result);
}
}
else
{
using (StringWriter writer = new StringWriter())
{
using (V3SourceMap sourceMap = new V3SourceMap(writer))
{
settings.SymbolsMap = sourceMap;
sourceMap.StartPackage(minFile, mapFile);
minifier.FileName = file;
result.MinifiedContent = minifier.MinifyJavaScript(File.ReadAllText(file), settings);
if (!minifier.Errors.Any())
{
OnBeforeWritingMinFile(file, minFile);
File.WriteAllText(minFile, result.MinifiedContent, new UTF8Encoding(true));
OnAfterWritingMinFile(file, minFile);
}
else
{
AddAjaxminErrors(minifier, result);
}
}
result.SourceMap = writer.ToString();
}
}
if (produceGzipFile)
{
GzipFile(minFile);
}
}
catch (Exception ex)
{
result.Errors.Add(new MinificationError
{
FileName = file,
Message = ex.Message,
LineNumber = 0,
ColumnNumber = 0
});
}
return(result);
}
private static MinificationResult MinifyCss(string file, bool produceGzipFile)
{
string content = File.ReadAllText(file);
string minFile = GetMinFileName(file);
var settings = new CssSettings()
{
CommentMode = CssComment.Hacks
};
var minifier = new Minifier();
var result = new MinificationResult(file, null, null);
try
{
result.MinifiedContent = minifier.MinifyStyleSheet(content, settings);
if (!minifier.Errors.Any())
{
OnBeforeWritingMinFile(file, minFile);
File.WriteAllText(minFile, result.MinifiedContent, new UTF8Encoding(true));
OnAfterWritingMinFile(file, minFile);
if (produceGzipFile)
GzipFile(minFile);
}
else
{
AddAjaxminErrors(minifier, result);
}
}
catch (Exception ex)
{
result.Errors.Add(new MinificationError
{
FileName = file,
Message = ex.Message,
LineNumber = 0,
ColumnNumber = 0
});
}
return result;
}
private static MinificationResult MinifyHtml(string file, bool produceGzipFile)
{
var settings = new HtmlMinificationSettings
{
RemoveOptionalEndTags = false,
AttributeQuotesRemovalMode = WebMarkupMin.Core.HtmlAttributeQuotesRemovalMode.Html5,
RemoveRedundantAttributes = false,
};
string content = File.ReadAllText(file);
string minFile = GetMinFileName(file);
var minifier = new HtmlMinifier(settings);
var minResult = new MinificationResult(file, null, null);
try
{
MarkupMinificationResult result = minifier.Minify(content, generateStatistics: true);
minResult.MinifiedContent = result.MinifiedContent;
if (!result.Errors.Any())
{
OnBeforeWritingMinFile(file, minFile);
File.WriteAllText(minFile, result.MinifiedContent, new UTF8Encoding(true));
OnAfterWritingMinFile(file, minFile);
if (produceGzipFile)
GzipFile(minFile);
}
else
{
foreach (var error in result.Errors)
{
minResult.Errors.Add(new MinificationError
{
FileName = file,
Message = error.Message,
LineNumber = error.LineNumber,
ColumnNumber = error.ColumnNumber
});
}
}
}
catch (Exception ex)
{
minResult.Errors.Add(new MinificationError
{
FileName = file,
Message = ex.Message,
LineNumber = 0,
ColumnNumber = 0
});
}
return minResult;
}
private static MinificationResult MinifyJavaScript(string file, bool produceGzipFile, bool produceSourceMap)
{
var settings = new CodeSettings()
{
EvalTreatment = EvalTreatment.Ignore,
TermSemicolons = true,
PreserveImportantComments = false,
};
var minifier = new Minifier();
var result = new MinificationResult(file, null, null);
string minFile = GetMinFileName(file);
string mapFile = minFile + ".map";
try
{
if (!produceSourceMap)
{
result.MinifiedContent = minifier.MinifyJavaScript(File.ReadAllText(file), settings);
if (!minifier.Errors.Any())
{
OnBeforeWritingMinFile(file, minFile);
File.WriteAllText(minFile, result.MinifiedContent, new UTF8Encoding(true));
OnAfterWritingMinFile(file, minFile);
}
else
{
AddAjaxminErrors(minifier, result);
}
}
else
{
using (StringWriter writer = new StringWriter())
{
using (V3SourceMap sourceMap = new V3SourceMap(writer))
{
settings.SymbolsMap = sourceMap;
sourceMap.StartPackage(minFile, mapFile);
minifier.FileName = file;
result.MinifiedContent = minifier.MinifyJavaScript(File.ReadAllText(file), settings);
if (!minifier.Errors.Any())
{
OnBeforeWritingMinFile(file, minFile);
File.WriteAllText(minFile, result.MinifiedContent, new UTF8Encoding(true));
OnAfterWritingMinFile(file, minFile);
}
else
{
AddAjaxminErrors(minifier, result);
}
}
result.SourceMap = writer.ToString();
}
}
if (produceGzipFile)
GzipFile(minFile);
}
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 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);
}
