public string CompressContent(string content)
{
var minifer = new Minifier();
if (codeSettings != null)
{
return minifer.MinifyJavaScript(content, codeSettings, globalNames);
}
else
{
return minifer.MinifyJavaScript(content, globalNames);
}
}
private static void MinifyFile(string file, string minFile, CodeSettings settings, bool isBundle)
{
Minifier minifier = new Minifier();
if (!isBundle)
{
minifier.FileName = Path.GetFileName(file);
}
string content = minifier.MinifyJavaScript(File.ReadAllText(file), settings);
if (File.Exists(minFile) && content == File.ReadAllText(minFile))
return;
if (WESettings.GetBoolean(WESettings.Keys.GenerateJavaScriptSourceMaps))
{
content += "\r\n/*\r\n//# sourceMappingURL=" + Path.GetFileName(minFile) + ".map\r\n*/";
}
ProjectHelpers.CheckOutFileFromSourceControl(minFile);
using (StreamWriter writer = new StreamWriter(minFile, false, new UTF8Encoding(true)))
{
writer.Write(content);
}
if (WESettings.GetBoolean(WESettings.Keys.JavaScriptEnableGzipping))
CssSaveListener.GzipFile(file, minFile, content);
}
private static MinificationResult MinifyJavaScript(Config config, string file)
{
string content = File.ReadAllText(file);
var settings = JavaScriptOptions.GetSettings(config);
if (config.Minify.ContainsKey("enabled") && config.Minify["enabled"].ToString().Equals("false", StringComparison.OrdinalIgnoreCase))
return null;
var minifier = new Minifier();
string ext = Path.GetExtension(file);
string minFile = file.Substring(0, file.LastIndexOf(ext)) + ".min" + ext;
string mapFile = minFile + ".map";
string result = minifier.MinifyJavaScript(content, settings);
bool containsChanges = FileHelpers.HasFileContentChanged(minFile, result);
if (!string.IsNullOrEmpty(result))
{
OnBeforeWritingMinFile(file, minFile, containsChanges);
if (containsChanges)
{
File.WriteAllText(minFile, result, new UTF8Encoding(true));
}
OnAfterWritingMinFile(file, minFile, containsChanges);
GzipFile(config, minFile, containsChanges);
}
return new MinificationResult(result, null);
}
public override IEnumerable<PvcCore.PvcStream> Execute(IEnumerable<PvcCore.PvcStream> inputStreams)
{
var minifyStreams = inputStreams.Where(x => Regex.IsMatch(x.StreamName, @"\.(js|css)$"));
var resultStreams = new List<PvcStream>();
foreach (var inputStream in minifyStreams)
{
var fileContent = new StreamReader(inputStream).ReadToEnd();
var minifier = new Minifier();
var resultContent = inputStream.StreamName.EndsWith(".js") ? minifier.MinifyJavaScript(fileContent) : minifier.MinifyStyleSheet(fileContent);
foreach (var error in minifier.ErrorList)
{
Console.Error.WriteLine(error.ToString());
}
var dirName = Path.GetDirectoryName(inputStream.StreamName);
var fileName = Path.GetFileNameWithoutExtension(inputStream.StreamName) + ".min" + Path.GetExtension(inputStream.StreamName);
var resultStream = PvcUtil.StringToStream(resultContent, Path.Combine(dirName, fileName));
resultStreams.Add(resultStream);
}
return inputStreams.Where(x => !minifyStreams.Any(y => y.StreamName == x.StreamName)).Concat(resultStreams);
}
public string Compile(IEnumerable<string> files)
{
var blocks = new List<Block>();
// ReSharper disable once LoopCanBeConvertedToQuery
foreach (string file in files)
{
var parser = new JSParser(File.ReadAllText(file)) { FileContext = file };
var block = parser.Parse(new CodeSettings
{
EvalTreatment = EvalTreatment.MakeImmediateSafe,
PreserveImportantComments = false
});
if (block != null)
{
blocks.Add(block);
}
}
Block fst = blocks[0];
for (int i = 1; i < blocks.Count; i++)
{
fst.Append(blocks[i]);
}
string sequenceCode = fst.ToCode();
var minifier = new Minifier();
string compiled = minifier.MinifyJavaScript(
sequenceCode,
new CodeSettings
{
EvalTreatment = EvalTreatment.MakeImmediateSafe,
PreserveImportantComments = false
});
return compiled;
}
protected override void BuildResult(Stream fs, List <string> filePaths)
{
var minifier = new Microsoft.Ajax.Utilities.Minifier();
minifier.WarningLevel = 3;
var styleBuilder = new StringBuilder();
foreach (var style in filePaths)
{
var text = FileOperator.ReadAllText(style);
if (style.IndexOf(".min.") == -1)
{
try
{
var mintext = minifier.MinifyJavaScript(text);
text = mintext;
}
catch (Exception)
{
}
}
styleBuilder.Append(';');
styleBuilder.AppendLine(text);
}
var buffer = Encoding.UTF8.GetBytes(styleBuilder.ToString());
fs.Write(buffer, 0, buffer.Length);
}
public static void ExtractCore(Translator translatorInstance, string outputPath, bool nodebug = false)
{
var clrPath = translatorInstance.BridgeLocation;
var assembly = System.Reflection.Assembly.UnsafeLoadFrom(clrPath);
// We can only have Beautified, Minified or Both, so this test has inverted logic:
// output beautified if not minified only == (output beautified or output both)
if (translatorInstance.AssemblyInfo.OutputFormatting != JavaScriptOutputType.Minified)
{
ExtractResourceAndWriteToFile(outputPath, assembly, "Bridge.Resources.bridge.js", "bridge.js");
}
if (translatorInstance.AssemblyInfo.GenerateTypeScript)
{
ExtractResourceAndWriteToFile(outputPath, assembly, "Bridge.Resources.bridge.d.ts", "bridge.d.ts");
}
// Like above test: output minified if not beautified only == (out minified or out both)
if (translatorInstance.AssemblyInfo.OutputFormatting != JavaScriptOutputType.Formatted)
{
if (!nodebug)
{
ExtractResourceAndWriteToFile(outputPath, assembly, "Bridge.Resources.bridge.js", "bridge.min.js", (reader) => { var minifier = new Minifier(); return minifier.MinifyJavaScript(reader.ReadToEnd(), new CodeSettings { TermSemicolons = true }); });
}
}
}
/// <summary>
/// Minifies the specified JavaScript.
/// </summary>
/// <param name="resource">The JavaScript to minify.</param>
/// <returns>The minified JavaScript, if minification was successful; otherwise, the original JavaScript with minification errors appended at the end.</returns>
public string Minify(string resource)
{
if (String.IsNullOrEmpty(resource))
{
return resource;
}
var settings = new CodeSettings
{
AllowEmbeddedAspNetBlocks = false,
EvalTreatment = EvalTreatment.MakeAllSafe
};
var minifier = new Minifier();
try
{
resource = minifier.MinifyJavaScript(resource, settings);
}
catch
{
var minificationErrors = String.Join(Environment.NewLine, minifier.Errors);
resource = AppendMinificationErrors(resource, minificationErrors);
if (mLogErrors)
{
CoreServices.EventLog.LogEvent("W", "Resource minification", "JavaScriptMinificationFailed", minificationErrors);
}
}
return resource;
}
public string Minify(string content)
{
var minifer = new Minifier();
codeSettings = codeSettings ?? new CodeSettings();
codeSettings.SetKnownGlobalNames(globalNames);
return minifer.MinifyJavaScript(content, codeSettings);
}
/// <summary>
/// (Awaitable) Compiles content with the give configuration (files and minify flag).
/// </summary>
/// <param name="content">Content to Compile</param>
/// <param name="minify"></param>
/// <returns>string with compiled content</returns>
public Task<string> CompileAsync(string content, bool minify)
{
if (!minify)
return Task.FromResult(content);
var minifier = new Minifier();
return Task.FromResult(minifier.MinifyJavaScript(content));
}
public virtual string Minify<T>(string unMinifiedContent) where T : IResourceType
{
if (typeof(T) == typeof(CssResource))
return minifier.MinifyStyleSheet(unMinifiedContent);
if (typeof(T) == typeof(JavaScriptResource))
return minifier.MinifyJavaScript(unMinifiedContent, settings);
throw new ArgumentException("Cannot Minify ResourceStrings of unknown type", "unMinifiedContent");
}
public void Minify()
{
var minifer = new Minifier();
var codeSettings = new CodeSettings();
var content = _fileSystem.BundleFiles(_files);
var minified = minifer.MinifyJavaScript(content, codeSettings);
_fileSystem.File.WriteAllText(_outputPath, minified);
}
protected override string Compress(string source)
{
var minifier = new Minifier();
var minified = minifier.MinifyJavaScript(source);
if (minifier.Errors.Count > 0)
{
return source;
}
return minified;
}
private static void Generate(string outputPath, bool minify, Minifier minifier, string js)
{
if (minify)
{
File.WriteAllText(outputPath, minifier.MinifyJavaScript(js));
}
else
{
File.WriteAllText(outputPath, js);
}
}
public string Minify(string source)
{
CodeSettings settings = new CodeSettings
{
PreserveImportantComments = false,
PreserveFunctionNames = true
};
Minifier doMin = new Minifier();
string mind = doMin.MinifyJavaScript(source, settings);
return mind;
}
public override void Process(BundleContext context, BundleResponse response)
{
response.ContentType = ContentType.JavaScript;
if (context.HttpContext.IsDebuggingEnabled)
{
return;
}
var minifier = new Minifier();
response.Content = minifier.MinifyJavaScript(response.Content);
}
public void Write(Module module)
{
var minifier = new Minifier();
textWriter.Write(
minifier.MinifyJavaScript(
string.Join(
"\r\n",
module.Resources.Select(s => GetJavaScript(rootDirectory + s.Path))
)
)
);
}
public void ProcessRequest(HttpContext context)
{
_context = context;
Map("~/Client/routes/", BuildName);
Map("~/Client/controls/", file => String.Format("controls/{0}", Path.GetFileNameWithoutExtension(file)));
var minifier = new Minifier();
context.Response.ContentType = "text/javascript";
var content = minifier.MinifyJavaScript(_builder.ToString());
context.Response.Write(minifier.ErrorList.Any() ? _builder.ToString() : content);
context.Response.End();
}
static void Main(string[] args)
{
bool minify = false;
bool absolute = false;
if (args.Length < 1)
{
Console.WriteLine("Usage: {0} [url] (/minify) (/absolute)", typeof(Program).Assembly.GetName().Name);
return;
}
ParseArguments(args, out minify, out absolute);
string url = args[0];
string baseUrl = null;
if (!url.EndsWith("/"))
{
url += "/";
}
if(!url.EndsWith("signalr"))
{
url += "signalr/";
}
baseUrl = url;
if (!url.EndsWith("hubs", StringComparison.OrdinalIgnoreCase))
{
url += "hubs";
}
var uri = new Uri(url);
var minifier = new Minifier();
var wc = new WebClient();
string js = wc.DownloadString(uri);
if (absolute)
{
js = Regex.Replace(js, @"\(""(.*?/signalr)""\)", m => "(\"" + baseUrl + "\")");
}
if (minify)
{
Console.WriteLine(minifier.MinifyJavaScript(js));
}
else
{
Console.WriteLine(js);
}
}
public static string MinifiContentToString(string content, ContentType contentType)
{
Minifier minifier = new Minifier();
if (contentType == ContentType.css)
{
content = minifier.MinifyStyleSheet(content);
}
else if (contentType == ContentType.javascript)
{
content = minifier.MinifyJavaScript(content);
}
return content;
}
public static byte[] MinifyContent(string content, ContentType contentType)
{
Minifier minifier = new Minifier();
if (contentType == ContentType.css)
{
content = minifier.MinifyStyleSheet(content);
}
else if (contentType == ContentType.javascript)
{
content = minifier.MinifyJavaScript(content);
}
return Encoding.UTF8.GetBytes(content);
}
private static string MinifyJavaScript(string input)
{
Minifier minifier = new Minifier();
CodeSettings settings = new CodeSettings();
settings.RemoveUnneededCode = false;
settings.PreserveFunctionNames = true;
string output = minifier.MinifyJavaScript(input, settings);
if (!String.IsNullOrEmpty(output))
{
output = output + ";";
}
return output;
}
private static void Minify(HttpResponse response, string file, string ext)
{
string content = File.ReadAllText(file);
Minifier minifier = new Minifier();
if (ext == ".css")
{
CssSettings settings = new CssSettings() { CommentMode = CssComment.None };
response.Write(minifier.MinifyStyleSheet(content, settings));
}
else if (ext == ".js")
{
CodeSettings settings = new CodeSettings() { PreserveImportantComments = false };
response.Write(minifier.MinifyJavaScript(content, settings));
}
}
private void minifyJS(Entity entity, CodeSettings settings)
{
Microsoft.Ajax.Utilities.Minifier minifier = new Microsoft.Ajax.Utilities.Minifier();
string name = entity.GetAttributeValue <string>("displayname");
byte[] jsFileBytes = Convert.FromBase64String(entity.GetAttributeValue <string>("content"));
string originalJS = UnicodeEncoding.UTF8.GetString(jsFileBytes);
string minifiedJs = minifier.MinifyJavaScript(originalJS, settings);
byte[] minifiedJsBytes = UnicodeEncoding.UTF8.GetBytes(minifiedJs);
string minifiedJsBytesString = Convert.ToBase64String(minifiedJsBytes);
Entity updatedWebResource = new Entity(entity.LogicalName);
updatedWebResource.Attributes.Add("content", minifiedJsBytesString);
updatedWebResource.Id = entity.Id;
this.service.Update(updatedWebResource);
}
/// <summary>
/// Minifies the JS.
/// </summary>
/// <param name="js">The js.</param>
/// <param name="obfuscate">if set to <c>true</c> [obfuscate].</param>
/// <returns></returns>
public static String MinifyJs(String js, bool obfuscate)
{
try
{
if (String.IsNullOrWhiteSpace(js))
return js;
var min = new Minifier();
return min.MinifyJavaScript(js);
//return Yahoo.Yui.Compressor.JavaScriptCompressor.Compress(js, true, obfuscate, true, true, 80, Encoding.UTF8, CultureInfo.InvariantCulture);
}
catch (Exception ex)
{
Trace.WriteLine("JS code that could not be minified:"); //Minification is usually done in Release mode where Debug is not available
Trace.WriteLine(js);
throw new DextopException("JS minification failed. See inner exception for details.", ex);
}
}
public void Process(BundleContext context, BundleResponse response)
{
var minifer = new Minifier();
var cs = new CodeSettings {ManualRenamesProperties = false,LocalRenaming = LocalRenaming.KeepAll};
var content = new StringBuilder();
foreach (var file in response.Files)
{
var path = HttpContext.Current.Server.MapPath(file.IncludedVirtualPath);
using (var reader = new StreamReader(path))
{
content.Append(reader.ReadToEnd());
}
}
response.ContentType = "application/javascript";
var responseContent = minifer.MinifyJavaScript(content.ToString(), cs);
response.Content = responseContent;
}
private static void Generate(string outputPath, bool minify, Minifier minifier, string js, bool amd, string signalrAmdAlias)
{
var jsText = js;
if (amd)
{
jsText = WrapWithAmdDefinition(js, signalrAmdAlias);
}
if (minify)
{
File.WriteAllText(outputPath, minifier.MinifyJavaScript(jsText));
}
else
{
File.WriteAllText(outputPath, jsText);
}
}
public static void ExtractCore(Translator translatorInstance, string outputPath, bool nodebug = false)
{
var clrPath = translatorInstance.BridgeLocation;
var assembly = System.Reflection.Assembly.UnsafeLoadFrom(clrPath);
string resourceName;
// We can only have Beautified, Minified or Both, so this test has inverted logic:
// output beautified if not minified only == (output beautified or output both)
if (translatorInstance.AssemblyInfo.OutputFormatting != JavaScriptOutputType.Minified)
{
resourceName = "Bridge.Resources.bridge.js";
using (Stream stream = assembly.GetManifestResourceStream(resourceName))
{
using (StreamReader reader = new StreamReader(stream))
{
File.WriteAllText(Path.Combine(outputPath, "bridge.js"), reader.ReadToEnd());
}
}
}
// Like above test: output minified if not beautified only == (out minified or out both)
if (translatorInstance.AssemblyInfo.OutputFormatting != JavaScriptOutputType.Formatted)
{
if (!nodebug)
{
resourceName = "Bridge.Resources.bridge.js";
using (Stream stream = assembly.GetManifestResourceStream(resourceName))
{
using (StreamReader reader = new StreamReader(stream))
{
var code = reader.ReadToEnd();
var minifier = new Minifier();
File.WriteAllText(Path.Combine(outputPath, "bridge.min.js"), minifier.MinifyJavaScript(code), System.Text.UTF8Encoding.UTF8);
}
}
}
}
}
public ActionResult AppConfigData()
{
try
{
string js = string.Format(@"var appData = {0}", CommonUtility.AppsettingsToJson());
Minifier minifier = new Minifier();
string minifiedJs = minifier.MinifyJavaScript(js, new CodeSettings
{
EvalTreatment = EvalTreatment.MakeImmediateSafe,
PreserveImportantComments = false
});
return JavaScript(js);
}
catch (Exception ex)
{
ex.ExceptionValueTracker();
}
return null;
}
public static string Minify(string fullFileName, string text, EnvDTE.ProjectItem projectItem,CodeSettings codeSettings)
{
Minifier minifier = new Minifier();
string mini = minifier.MinifyJavaScript(text,codeSettings);
foreach (var err in minifier.ErrorList)
{
if (TaskList.Instance == null)
{
Console.WriteLine(string.Format("{0}({1},{2}){3}", fullFileName, 1, 1, err));
}
else
{
TaskList.Instance.Add(projectItem.ContainingProject, Microsoft.VisualStudio.Shell.TaskErrorCategory.Error, fullFileName, err.StartLine, err.StartColumn, err.Message);
}
}
return mini;
}
private static async Task<Stream> Do(ProjectItem projectItem)
{
string content;
using (var reader = new StreamReader(await projectItem.OpenRead().ConfigureAwait(false)))
{
content = await reader.ReadToEndAsync().ConfigureAwait(false);
}
var minifier = new Minifier();
content = minifier.MinifyJavaScript(content);
var stream = new MemoryStream();
var writer = new StreamWriter(stream);
writer.Write(content);
writer.Flush();
stream.Seek(0, SeekOrigin.Begin);
return stream;
}
public void Process(BundleContext context, BundleResponse response)
{
if (context == null)
throw new ArgumentNullException("context");
if (response == null)
throw new ArgumentNullException("response");
if (!context.EnableInstrumentation) {
var minifier = new Minifier();
string str = minifier.MinifyJavaScript(response.Content, new CodeSettings {
MinifyCode = true,
EvalTreatment = EvalTreatment.MakeImmediateSafe,
PreserveImportantComments = false,
LocalRenaming = LocalRenaming.KeepAll
});
if (minifier.ErrorList.Count > 0)
GenerateErrorResponse(response, minifier.ErrorList);
else
response.Content = str;
}
response.ContentType = JsContentType;
}
private static void MinifyFile(string file, string minFile, CodeSettings settings, bool isBundle)
{
Minifier minifier = new Minifier();
if (!isBundle)
{
minifier.FileName = Path.GetFileName(file);
}
string content = minifier.MinifyJavaScript(File.ReadAllText(file), settings);
if (WESettings.GetBoolean(WESettings.Keys.GenerateJavaScriptSourceMaps))
{
content += Environment.NewLine + "//@ sourceMappingURL=" + Path.GetFileName(minFile) + ".map";
}
ProjectHelpers.CheckOutFileFromSourceControl(minFile);
using (StreamWriter writer = new StreamWriter(minFile, false, new UTF8Encoding(true)))
{
writer.Write(content);
}
}
/// <summary>
/// Main Method (Entry point to the program).
/// </summary>
/// <param name="args"></param>
static void Main(string[] args)
{
/// instantiate a code settings object.
CodeSettings cs = new CodeSettings();
cs.QuoteObjectLiteralProperties = true;
cs.PreserveImportantComments = false;
/// Extract the bookmarklet wrapper javascript from the js wrapper file.
/// This file is the defines the bookmarklet javascript entry point and wraps each bookmarklet within this javascript.
string bookmarkletMainJSWrapper = System.IO.File.ReadAllText(Properties.Settings.Default.BookmarkletMainJSWrapper);
/// Read all the HTML Template file for adding the bookmarklets as links into.
string htmlTemplate = System.IO.File.ReadAllText(Properties.Settings.Default.BookmarkletHtmlTemplate);
string importableTemplate = System.IO.File.ReadAllText(Properties.Settings.Default.BookmarkletHtmlImportableTemplate);
/// A list of all the bookarklets from the bookmarklets folder
List <Bookmarklet> bookmarklets = new List <Bookmarklet>();
#region Load all bookmarklets
/// For each bookmarklet js in the bookmarklets folder
foreach (string file in System.IO.Directory.GetFiles(Properties.Settings.Default.BookmarkletsFolder))
{
/// get the file info
FileInfo fi = new FileInfo(file);
// if the file is not a js file skip
if (fi.Extension.ToLower() != ".js")
{
continue;
}
/// Instantite the bookmarklet object populating all the properties
Bookmarklet bookmarklet = new Bookmarklet();
bookmarklet.Name = fi.Name.Replace(".js", "");
bookmarklet.javascript = System.IO.File.ReadAllText(file);
/// Extract the bookmarklet info from the xml documentation notation
int firstIndex = bookmarklet.javascript.IndexOf("<BookmarkletInfo>");
int lastindex = bookmarklet.javascript.LastIndexOf("</BookmarkletInfo>") + ("</BookmarkletInfo>").Length;
if (firstIndex > 0)
{
string bookmarkletInfo = bookmarklet.javascript.Substring(firstIndex, lastindex - firstIndex);
XDocument doc = XDocument.Parse(bookmarkletInfo);
var nameNode = doc.XPathSelectElement("/BookmarkletInfo/Name");
if (nameNode != null)
{
bookmarklet.Name = nameNode.Value.ToString().Trim();
}
var descriptionNode = doc.XPathSelectElement("/BookmarkletInfo/Description");
if (descriptionNode != null)
{
bookmarklet.Description = InnerXml(descriptionNode).Trim();
}
}
/// update the bookmarklet javascript by inserting it into the main wrapper js
/// witha replace of "//[[Bookmarklet-Code-Inserted-Here]]" with the bookmarklet javascript
bookmarklet.javascript = bookmarkletMainJSWrapper.Replace("//[[Bookmarklet-Code-Inserted-Here]]", bookmarklet.javascript);
// add it to the list of bookmarklets.
bookmarklets.Add(bookmarklet);
}
#endregion Load all bookmarklets
#region output all bookmarklets into the html output file based on the template.
string bookmarkletHtml = "";
string bookmarkletImport = "";
///Instantiate a minifer instance
Minifier minifier = new Microsoft.Ajax.Utilities.Minifier();
foreach (var bookmarklet in bookmarklets)
{
//bookmarkletHtml += "<a href='javascript:" + HttpUtility.JavaScriptStringEncode(jsMinifer.Compress(kvp.Value)) + "'>" + kvp.Key + "</a>" + Environment.NewLine;
bookmarkletHtml += "<p>";
/// append the bookmarklet js minified. Replace all ' with \\' to escape any js quotes.
bookmarkletHtml += "<a href=\"javascript:" + minifier.MinifyJavaScript(bookmarklet.javascript, cs).Replace("'", "\\'").Replace("\"", "'") + "\">" + bookmarklet.Name + "</a>" + Environment.NewLine;
if (!string.IsNullOrEmpty(bookmarklet.Description))
{
bookmarkletHtml += "<br/>";
bookmarkletHtml += bookmarklet.Description;
}
bookmarkletHtml += "</p>";
/// append the bookmarklet js minified. Replace all ' with \\' to escape any js quotes.
bookmarkletImport += "\t\t<DT><A HREF=\"javascript:" + minifier.MinifyJavaScript(bookmarklet.javascript, cs).Replace("'", "\\'").Replace("\"", "'") + "\">" + bookmarklet.Name + "</A>" + Environment.NewLine;
}
string html = htmlTemplate.Replace("<!--Bookmarklets-->", bookmarkletHtml);
/// write the results to the html output file
File.WriteAllText(Properties.Settings.Default.BookmarkletHtmlOutput, html);
html = importableTemplate.Replace("<!--Bookmarklets-->", bookmarkletImport);
/// write the results to the html output file
File.WriteAllText(Properties.Settings.Default.BookmarkletImportOutput, html);
#endregion output all bookmarklets into the html output file based on the template.
}
