public static string Minify(string text, MinifyType mode,Yui.CssSettings cssOptions)
{
if (string.IsNullOrEmpty(text))
{
return text;
}
var cssmode = mode == MinifyType.yuiHybrid ? CssCompressionType.Hybrid
: mode == MinifyType.yuiMARE ? CssCompressionType.MichaelAshRegexEnhancements
: CssCompressionType.StockYuiCompressor;
return CssCompressor.Compress(text, cssOptions.ColumnWidth, cssmode, cssOptions.RemoveComments);
}
public static string Minify(string text, MinifyType mode, Yui.CssSettings cssOptions)
{
if (string.IsNullOrEmpty(text))
{
return(text);
}
var compressor = new CssCompressor();
compressor.CompressionType = CompressionType.Standard;
compressor.LineBreakPosition = cssOptions.ColumnWidth;
compressor.RemoveComments = cssOptions.RemoveComments;
return(compressor.Compress(text));
}
public MinifiedFile FindFileByFullName(string root, string fullName, MinifyType minifyType)
{
if (minifyType == MinifyType.CSHtml)
{
return(UserSettings.CSHtmlFiles.Find(x => x.GetFullSourcePath(root) == fullName));
}
else if (minifyType == MinifyType.Js)
{
return(UserSettings.JsFiles.Find(x => x.GetFullSourcePath(root) == fullName));
}
else
{
return(null);
}
}
public MinifyType GetMinifyType(string fullFileName)
{
this.Settings = Settings.Instance(fullFileName);
MinifyType mode = MinifyType.yui;
if (this.IsChirpMichaelAshLessFile(fullFileName) || this.IsChirpHybridLessFile(fullFileName) || this.IsChirpLessFile(fullFileName))
{
mode = this.IsChirpMichaelAshLessFile(fullFileName) ? MinifyType.yuiMARE
: this.IsChirpHybridLessFile(fullFileName) ? MinifyType.yuiHybrid
: MinifyType.yui;
}
if (this.IsChirpMSAjaxLessFile(fullFileName))
{
mode = MinifyType.msAjax;
}
return(mode);
}
public MinifiedFile FindFile(string path, string relativePath, MinifyType minifyType)
{
if (minifyType == MinifyType.CSHtml)
{
return(UserSettings.CSHtmlFiles.Find(x => x.SourceFile == relativePath ||
x.SourceFile == path ||
x.OutputFile == relativePath ||
x.OutputFile == path));
}
else if (minifyType == MinifyType.Js)
{
return(UserSettings.JsFiles.Find(x => x.SourceFile == relativePath ||
x.SourceFile == path ||
x.OutputFile == relativePath ||
x.OutputFile == path));
}
else
{
return(null);
}
}
public MinifyType GetMinifyType(string fullFileName)
{
this.Settings = Settings.Instance(fullFileName);
MinifyType mode = MinifyType.gctAdvanced;
if (this.IsChirpGctCoffeeScriptFile(fullFileName))
{
mode = MinifyType.gctAdvanced;
}
if (this.IsChirpMSAjaxCoffeeScriptFile(fullFileName))
{
mode = MinifyType.msAjax;
}
if (this.IsChirpSimpleCoffeeScriptFile(fullFileName))
{
mode = MinifyType.gctSimple;
}
if (this.IsChirpWhiteSpaceCoffeeScriptFile(fullFileName))
{
mode = MinifyType.gctWhiteSpaceOnly;
}
if (this.IsChirpYUICoffeeScriptFile(fullFileName))
{
mode = MinifyType.yui;
}
if (this.IsChirpUglifyCoffeeScriptFile(fullFileName))
{
mode = MinifyType.uglify;
}
return(mode);
}
internal static IHtmlString BaseBundle(MinifyType bundleType, string bundleName, params string[] filePaths)
{
var newFiles = CheckFiles(filePaths);
if (newFiles == null)
{
return new HtmlString(string.Empty);
}
var bundles = BundleTable.Bundles;
BundleTable.EnableOptimizations = EnableBundle;
string name = "";
if (string.IsNullOrWhiteSpace(bundleName))
{
name = BundleName;
}
IHtmlString htmlString = null;
switch (bundleType)
{
case MinifyType.Javascript:
//var bundle = new ScriptBundle(name);
//bundle.Transforms.Add(new MyBundlePlatform("BEGIN TEST INTERFACE", "END TEST INTERFACE"));
//bundle.Include(newFiles);
var bundle = new Bundle(name, new MyBundlePlatform("// BEGIN TEST INTERFACE", "// END TEST INTERFACE"));
bundle.Include(newFiles);
bundles.Add(bundle);
return Scripts.Render(name);
case MinifyType.Css:
bundles.Add(new StyleBundle(name).Include(newFiles));
return Styles.Render(name);
}
return new HtmlString(string.Empty);
}
private static string BundleInlines(MinifyType bundleType, Func<object, object> textFunc)
{
string notMinified = string.Empty;
notMinified = (textFunc.Invoke(new object()) ?? "").ToString();
if (!EnableBundle)
{
return notMinified;
}
var minifier = new Minifier();
string minified = string.Empty;
minifier.MinifyJavaScript("", new CodeSettings());
switch (bundleType)
{
case MinifyType.Javascript:
minified = minifier.MinifyJavaScript(notMinified, new CodeSettings
{
EvalTreatment = EvalTreatment.MakeImmediateSafe,
PreserveImportantComments = false
});
break;
case MinifyType.Css:
minified = minifier.MinifyStyleSheet(notMinified, new CssSettings
{
});
break;
default:
break;
}
return minified;
}
public static string Minify(string fullFileName, string outputText, ProjectItem projectItem, MinifyType mode)
{
if (mode == MinifyType.Unspecified)
{
mode = Settings.Instance(fullFileName).DefaultCssMinifier;
}
switch (mode)
{
case MinifyType.msAjax:
return(MsCssEngine.Minify(fullFileName, outputText, projectItem));
case MinifyType.yui:
case MinifyType.yuiMARE:
case MinifyType.yuiHybrid:
default:
return(YuiCssEngine.Minify(outputText, mode));
}
}
public static string Minify(string fullFileName, string outputText, ProjectItem projectItem, MinifyType mode, string customArgument)
{
if (mode == MinifyType.Unspecified)
{
mode = Settings.Instance(fullFileName).DefaultJavaScriptMinifier;
}
switch (mode)
{
case MinifyType.gctAdvanced:
return(ClosureCompilerEngine.Minify(fullFileName, outputText, projectItem, ClosureCompilerCompressMode.ADVANCED_OPTIMIZATIONS, customArgument));
case MinifyType.gctSimple:
return(ClosureCompilerEngine.Minify(fullFileName, outputText, projectItem, ClosureCompilerCompressMode.SIMPLE_OPTIMIZATIONS, customArgument));
case MinifyType.gctWhiteSpaceOnly:
return(ClosureCompilerEngine.Minify(fullFileName, outputText, projectItem, ClosureCompilerCompressMode.WHITESPACE_ONLY, customArgument));
case MinifyType.msAjax:
return(MsJsEngine.Minify(fullFileName, outputText, projectItem));
case MinifyType.uglify:
return(UglifyEngine.Minify(fullFileName, outputText, projectItem));
case MinifyType.jsBeautifier:
return(UglifyEngine.Beautify(outputText));
default:
return(YuiJsEngine.Minify(fullFileName, outputText, projectItem));
}
}
public static string Minify(string fullFileName, string outputText, ProjectItem projectItem, MinifyType mode)
{
return(Minify(fullFileName, outputText, projectItem, mode, string.Empty));
}
public async Task AddToConfigFileAsync(DocumentNode document, string fullName, string relativePath, MinifyType minifyType)
{
if (Config is null)
{
return;
}
MinifiedFile minifiedFile;
switch (minifyType)
{
case MinifyType.Js:
minifiedFile = AddJsToConfigFile(relativePath);
Config.UserSettings.JsFiles.Add((JsMinifiedFile)minifiedFile);
break;
case MinifyType.CSHtml:
minifiedFile = await ThreadHelper.JoinableTaskFactory.RunAsync(() =>
{
var file = AddCSHtmlToConfigFileAsync(document, fullName, relativePath);
return(Task.FromResult(file));
});
Config.UserSettings.CSHtmlFiles.Add((CsHtmlMinifiedFile)minifiedFile);
break;
default:
throw new InvalidOperationException("Please create an issue on GitHub, if this throws.");
}
await MinifyFileAsync(minifiedFile);
SetConfigFile(Config.FullName);
}
public static string Minify(string text, MinifyType mode)
{
Settings settings = Settings.Instance();
return(Minify(text, mode, settings.YuiCssSettings));
}
public static string Minify(string text, MinifyType mode)
{
Settings settings = Settings.Instance();
return Minify(text, mode, settings.YuiCssSettings);
}
/// <summary>
/// <para>Minify the script code.</para>
/// </summary>
/// <param name="source">
/// <para>script code.</para>
/// </param>
/// <param name="type"></param>
/// <returns>
/// <para>Minified string.</para>
/// </returns>
public static string MinifyCode(String source, MinifyType type = MinifyType.Javascript)
{
try
{
if (_minify == null)
{
Assembly assembly;
try
{
assembly = Assembly.Load("AjaxMin");
}
catch (Exception exp)
{
assembly = null;
}
if (assembly != null)
{
var typeClass = assembly.GetType("Microsoft.Ajax.Utilities.Minifier");
if (typeClass != null)
{
_minify = assembly.CreateInstance("Microsoft.Ajax.Utilities.Minifier");
_codeSettings = assembly.CreateInstance("Microsoft.Ajax.Utilities.CodeSettings");
_minifyConverType = MinifyConverterType.AjaxMin;
}
else // old assembly
{
_minify = assembly.CreateInstance("Microsoft.Ajax.Utilities.ScriptCruncher");
_minifyConverType = MinifyConverterType.AjaxMinCrunch;
}
}
else
{
_minify = (int)0;
_minifyConverType = MinifyConverterType.Internal;
}
}
switch (type)
{
case MinifyType.Javascript:
switch (_minifyConverType)
{
case MinifyConverterType.AjaxMinCrunch:
return(_minify.Crunch(source) + ";"); // resolve error on minifier
case MinifyConverterType.AjaxMin:
_codeSettings.TermSemicolons = true;
return(_minify.MinifyJavaScript(source, _codeSettings));
case MinifyConverterType.Internal:
return(Mtn.Library.Web.Utils.JsMinifier.GetMinifiedCode(source));
}
break;
case MinifyType.Css:
switch (_minifyConverType)
{
case MinifyConverterType.AjaxMinCrunch:
return(_minify.Crunch(source));
case MinifyConverterType.AjaxMin:
return(_minify.MinifyStyleSheet(source));
case MinifyConverterType.Internal:
return(Mtn.Library.Web.Utils.CssMinifier.CssMinify(source));
}
break;
default:
throw new ArgumentOutOfRangeException("type");
}
}
catch (Exception exp)
{
Statistics.Add(exp.GetAllMessagesMtn());
return(source);
}
return(source);
}
