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. }