private static string CompressCSS(string path)
{
var rawcss = File.ReadAllText(path);
var cssCompressor = new CssCompressor();
var compressed = cssCompressor.Compress(rawcss);
return compressed;
}
internal YuiMinifier(int columnWidth)
{
compressor = new CssCompressor
{
LineBreakPosition = columnWidth,
};
}
public override void Process(BundleContext context, BundleResponse response)
{
var compressor = new CssCompressor();
response.Content = compressor.Compress(response.Content);
response.ContentType = ContentTypes.Css;
}
/// <inheritdoc cref="IResourceMinifier.Minify" />
public string Minify(Settings settings, ResourceSet resourceSet, string combinedContent)
{
var compressor = new CssCompressor();
compressor.LineBreakPosition = LineBreakPosition == null ? -1 : LineBreakPosition.Value;
compressor.RemoveComments = RemoveComments == null ? true : RemoveComments.Value;
return compressor.Compress(combinedContent);
}
public ResourceCompressor(CssCompressor cssCompressor, JavaScriptCompressor jsCompressor)
{
Ensure.That(() => cssCompressor).IsNotNull();
Ensure.That(() => jsCompressor).IsNotNull();
this.cssCompressor = cssCompressor;
this.jsCompressor = jsCompressor;
}
internal YuiMinifier(int columnWidth, CompressionType compressionType)
{
compressor = new CssCompressor
{
CompressionType = compressionType,
LineBreakPosition = columnWidth,
};
}
public YuiCssTransformer(CompressionType compressionType = CompressionType.Standard, int lineBreakPosition = -1, bool removeComments = true)
{
_compressor = new CssCompressor
{
CompressionType = compressionType,
LineBreakPosition = lineBreakPosition,
RemoveComments = removeComments
};
}
internal YuiMinifier(int columnWidth, CompressionType compressionType, bool removeComments)
{
compressor = new CssCompressor
{
CompressionType = compressionType,
LineBreakPosition = columnWidth,
RemoveComments = removeComments
};
}
public string Minify(string content)
{
CssCompressor cssCompressor = new CssCompressor
{
CompressionType = CompressionType.Standard,
RemoveComments = true,
LineBreakPosition = -1
};
return cssCompressor.Compress(content);
}
public static void cssInPlaceMinify(string dplUrl) {
var files = FileSources.pathsFromDpl(dplUrl).ToArray();
var compr = new CssCompressor();
foreach (var fn in files) {
var res = compr.Compress(File.ReadAllText(fn, Encoding.UTF8));
var destFn = fn.Replace(".css", ".min.css");
File.WriteAllText(destFn, res);
Trace.TraceInformation("Minified CSS: " + destFn);
}
}
public override void Process(BundleContext context, BundleResponse response)
{
response.ContentType = ContentTypes.Css;
if (context.HttpContext.IsDebuggingEnabled)
{
return;
}
var compressor = new CssCompressor();
response.Content = compressor.Compress(response.Content);
}
public ResourceCompressor(CssCompressor cssCompressor, JavaScriptCompressor jsCompressor)
{
if (cssCompressor == null)
{
throw new ArgumentNullException("cssCompressor");
}
if (jsCompressor == null)
{
throw new ArgumentNullException("jsCompressor");
}
this.cssCompressor = cssCompressor;
this.jsCompressor = jsCompressor;
}
public CompileResults Compile(string inPath, string outPath)
{
using (StreamReader sr = new StreamReader(inPath))
{
string content = sr.ReadToEnd();
var x = new CssCompressor();
string output = x.Compress(content);
using (StreamWriter sw = new StreamWriter(outPath))
{
sw.Write(output);
}
}
return null;
}
public static MvcHtmlString MinifyInlineCss(this HtmlHelper html, Func <object, object> markup)
{
string notMinifiedCss = (markup.Invoke(html.ViewContext)?.ToString() ?? "").TrimStart("<style>")
.TrimStart("<text>").TrimEnd("</style>").TrimEnd("</text>");
var minifier = new Yahoo.Yui.Compressor.CssCompressor()
{
RemoveComments = true
};
minifier.CompressionType = Yahoo.Yui.Compressor.CompressionType.Standard;
var minifiedCss = minifier.Compress(notMinifiedCss);
return(new MvcHtmlString("<style>" + minifiedCss + "</style>"));
}
private static string CompressCss(string content)
{
string results = "";
try
{
var cssCompressor = new CssCompressor();
results = cssCompressor.Compress(content);
}
catch (Exception ex)
{
WriteLog(ex);
}
return results;
}
/// <summary>
/// Process the request
/// </summary>
public void ProcessRequest(HttpContext context)
{
DateTime mod = new FileInfo(Assembly.GetExecutingAssembly().Location).LastWriteTime ;
var compressor = new CssCompressor() ;
if (File.Exists(context.Server.MapPath("~/Areas/Manager/Content/Css/Style.css"))) {
FileInfo file = new FileInfo(context.Server.MapPath("~/Areas/Manager/Content/Css/Style.css")) ;
mod = file.LastWriteTime > mod ? file.LastWriteTime : mod ;
}
if (!ClientCache.HandleClientCache(context, resource, mod)) {
StreamReader io = new StreamReader(Assembly.GetExecutingAssembly().GetManifestResourceStream(resource)) ;
context.Response.ContentType = "text/css" ;
#if DEBUG
context.Response.Write(io.ReadToEnd()) ;
#else
context.Response.Write(compressor.Compress(io.ReadToEnd()).Replace("\n","")) ;
#endif
io.Close() ;
// Now apply standard theme
if (ConfigurationManager.AppSettings["disable_manager_theme"] != "1") {
io = new StreamReader(Assembly.GetExecutingAssembly().GetManifestResourceStream(theme)) ;
#if DEBUG
context.Response.Write(io.ReadToEnd()) ;
#else
context.Response.Write(compressor.Compress(io.ReadToEnd()).Replace("\n","")) ;
#endif
io.Close() ;
}
// Now check for application specific styles
if (File.Exists(context.Server.MapPath("~/Areas/Manager/Content/Css/Style.css"))) {
io = new StreamReader(context.Server.MapPath("~/Areas/Manager/Content/Css/Style.css")) ;
#if DEBUG
context.Response.Write(io.ReadToEnd()) ;
#else
context.Response.Write(compressor.Compress(io.ReadToEnd()).Replace("\n","")) ;
#endif
io.Close() ;
}
}
}
/// <summary>
/// Filters the assets
/// </summary>
/// <param name="Assets">Assets to filter</param>
/// <returns>The filtered assets</returns>
public IList<IAsset> Filter(IList<IAsset> Assets)
{
if (Assets == null || Assets.Count == 0)
return new List<IAsset>();
if (Assets.FirstOrDefault().Type != AssetType.CSS)
return Assets;
var Processable = Assets.Where(x => !x.Minified);
if (Processable.FirstOrDefault() == null)
return Assets;
var Minifier = new CssCompressor { CompressionType = CompressionType.Standard, RemoveComments = true };
foreach (IAsset Asset in Processable.Where(x => x != null))
{
try
{
Asset.Content = Minifier.Compress(Asset.Content);
Asset.Minified = true;
}
catch { }
}
return Assets;
}
static void Main(string[] args)
{
foreach (var arg in args)
Console.WriteLine(arg);
List<string> cssFiles = new List<string>();
List<string> jsFiles = new List<string>();
foreach (var file in args)
{
if (file.EndsWith(".css"))
cssFiles.Add(file);
else if (file.EndsWith(".js"))
jsFiles.Add(file);
}
var cssCompressor = new CssCompressor();
var jsCompressor = new JavaScriptCompressor();
foreach(var jsFile in jsFiles){
var compress = jsCompressor.Compress(File.ReadAllText(jsFile));
var newPath = jsFile.Replace(".js", "") + ".min.js";
using (StreamWriter swr = new StreamWriter(newPath,false))
{
swr.Write(compress);
swr.Close();
}
}
foreach (var cssFile in cssFiles)
{
var compress = cssCompressor.Compress(File.ReadAllText(cssFile));
var newPath = cssFile.Replace(".css", "") + ".min.css";
using (StreamWriter swr = new StreamWriter(newPath, false))
{
swr.Write(compress);
swr.Close();
}
}
}
private string TransformContent(BundleResource bundleResource, HttpContext context)
{
var bundleType = bundleResource.Type;
var content = bundleResource.Content;
var serverpath = bundleResource.ServerPath;
try
{
if (bundleType == BundleResourceType.EmbeddedScript || bundleType == BundleResourceType.ScriptFile)
{
var compressor = new JavaScriptCompressor
{
CompressionType = CompressionType.Standard,
Encoding = Encoding.UTF8,
ObfuscateJavascript = bundleResource.ObfuscateJs
};
//Minimize
var contentOut = compressor.Compress(content.Trim()) + ";";
//Return deffered execution
if (ClientSettings.IsJavascriptDefferingEnabled)
{
return string.Format(ClientSettings.JavascriptDefferingScript,
JsonConvert.SerializeObject(contentOut));
}
return contentOut;
}
if (!string.IsNullOrEmpty(serverpath))
{
string directoryName = Path.GetDirectoryName(serverpath);
if (directoryName != null)
serverpath = directoryName.Replace('\\', '/');
}
if (bundleType == BundleResourceType.EmbeddedStyle || bundleType == BundleResourceType.StyleFile)
{
var compressor = new CssCompressor
{
CompressionType = CompressionType.Standard,
RemoveComments = true
};
return ReplaceUrls(compressor.Compress(content), serverpath, context);
}
if (bundleType == BundleResourceType.LessFile)
{
DotlessConfiguration cfg = DotlessConfiguration.GetDefaultWeb();
cfg.Web = true;
cfg.MinifyOutput = true;
cfg.MapPathsToWeb = true;
cfg.CacheEnabled = false;
//Prefilter
content = ReplaceImportRegex.Replace(content, match => ReplaceImports(match, serverpath));
string processed = ReplaceUrls(LessWeb.Parse(content, cfg), serverpath, context);
return processed;
}
}
catch (EcmaScript.NET.EcmaScriptException e)
{
_log.ErrorFormat("EcmaScriptException: {0} in {1} at {2} ({3}, {4}) at ", e.Message, serverpath, e.LineSource, e.LineNumber, e.ColumnNumber, e.ScriptStackTrace);
}
catch (Exception e)
{
_log.Error(e);
}
return content;
}
string YUI_CSS(string filesource, ConfigSettings.YUICompressionSettings.CSS CssSettings)
{
try
{
var csscompressor = new CssCompressor();
csscompressor.CompressionType = CssSettings.CompressionType;
csscompressor.LineBreakPosition = CssSettings.LineBreakPosition;
csscompressor.RemoveComments = CssSettings.RemoveComments;
return csscompressor.Compress(filesource);
}
catch (Exception ex)
{
var msg = ex.Message;
return filesource;
}
}
internal static string CSS(string css)
{
var cssCom = new CssCompressor();
return cssCom.Compress(css);
}
private void Minify(FileInfo source, FileInfo file)
{
if (Options.IsDebugLoggingEnabled)
Logger.Log("Generating minified css file.");
try
{
var css = File.ReadAllText(source.FullName);
string minified = "";
if (!string.IsNullOrEmpty(css))
{
var compressor = new CssCompressor { RemoveComments = true };
minified = compressor.Compress(css);
}
InteropHelper.CheckOut(file.FullName);
File.WriteAllText(file.FullName, minified, UTF8_ENCODING);
// nest
if (Options.IncludeCssInProject)
AddFileToProject(source, file, Options);
}
catch (Exception ex)
{
Logger.Log(ex, "Failed to generate minified css file.");
if (Options.ReplaceCssWithException)
SaveExceptionToFile(ex, file);
}
}
static string RunYuiCompressorForCss(IList<string> pSourceFilePaths, string pOutputFilePath,
bool pCompressFileContents = true, string pHeaderComment = null, bool pIncludeGenDateInHeaderComment = true)
{
var compressor = new CssCompressor();
compressor.RemoveComments = true;
return RunYuiCompressor(compressor, pSourceFilePaths, pOutputFilePath, pCompressFileContents, pHeaderComment, pIncludeGenDateInHeaderComment);
}
public CssMinifyCompiler()
{
_compiler = new CssCompressor();
}
/// <summary>
/// Creates a instance of inline CSS-code compressor
/// </summary>
/// <returns>Inline CSS-code compressor</returns>
private CssCompressor CreateInlineCssCompressorInstance()
{
var inlineCssCompressor = new CssCompressor();
ApplyCssSettingsToCssCompressor(inlineCssCompressor, _settings);
inlineCssCompressor.LineBreakPosition = -1;
return inlineCssCompressor;
}
/// <summary>
/// Applies a CSS settings to original CSS minifier
/// </summary>
/// <param name="originalMinifier">Original CSS minifier</param>
/// <param name="settings">CSS minifier settings</param>
private static void ApplyCssSettingsToOriginalCssMinifier(CssCompressor originalMinifier,
YuiCssMinificationSettings settings)
{
ApplyCommonSettingsToOriginalMinifier(originalMinifier, settings);
originalMinifier.RemoveComments = settings.RemoveComments;
}
/// <summary>
/// Creates a instance of original CSS minifier
/// </summary>
/// <param name="settings">CSS minifier settings</param>
/// <param name="isInlineCode">Flag for whether to create a settings for inline code</param>
/// <returns>Instance of original CSS minifier</returns>
private static CssCompressor CreateOriginalCssMinifierInstance(YuiCssMinificationSettings settings,
bool isInlineCode)
{
var originalMinifier = new CssCompressor();
ApplyCssSettingsToOriginalCssMinifier(originalMinifier, settings);
if (isInlineCode)
{
originalMinifier.LineBreakPosition = -1;
}
return originalMinifier;
}
public string Compress(string contents)
{
var cssCompressor = new CssCompressor();
return cssCompressor.Compress(contents);
}
/// <summary>
/// Constructs an instance of the YUI CSS Minifier
/// </summary>
/// <param name="settings">Settings of YUI CSS Minifier</param>
public YuiCssMinifier(YuiCssMinificationSettings settings)
{
_originalEmbeddedCssMinifier = CreateOriginalCssMinifierInstance(settings, false);
_originalInlineCssMinifier = CreateOriginalCssMinifierInstance(settings, true);
}
/// <summary>
/// OnItemProcessed event handler.
/// </summary>
/// <param name="sender"></param>
/// <param name="args"></param>
public void OnItemProcessed(object sender, EventArgs args)
{
var context = ((ItemProcessedEventArgs)args).Context;
string targetDataBase = context.PublishOptions.TargetDatabase.Name.ToLower();
Databases = Databases.ToLower();
if (Databases.Contains(targetDataBase))
{
using (new Sitecore.SecurityModel.SecurityDisabler())
{
// Get published item in target environment
var item = context.PublishHelper.GetTargetItem(context.ItemId);
// Check if item is published and it is a media item
if (item != null && item.Paths.IsMediaItem)
{
MediaItem mediaItem = new MediaItem(item);
string fileExtension = mediaItem.Extension.ToLower();
// Check if media item is css or js resource
if (fileExtension != "css" && fileExtension != "js")
{
return;
}
try
{
// Get Stream object of the media item
using (Stream mediaStream = mediaItem.GetMediaStream())
{
using (StreamReader sr = new StreamReader(mediaStream))
{
// Read contents of the media items into a String object
string originalString = sr.ReadToEnd();
string newString = String.Empty;
// If media item is CSS, then use CssCompressor for compression
if (fileExtension == "css")
{
newString = new CssCompressor().Compress(originalString);
}
// If media item is JS, then use JavaScriptCompressor for compression
else if (fileExtension == "js")
{
newString = new JavaScriptCompressor().Compress(originalString);
}
if (String.IsNullOrEmpty(newString))
{
return;
}
byte[] byteArray = Encoding.ASCII.GetBytes(newString);
using (MemoryStream stream = new MemoryStream(byteArray))
{
// Edit mediaItem and upload minified version
using (new EditContext((Item)mediaItem, SecurityCheck.Disable))
{
Sitecore.Resources.Media.Media media = MediaManager.GetMedia(mediaItem);
media.SetStream(new MediaStream(stream, fileExtension, mediaItem));
}
}
}
}
Sitecore.Diagnostics.Log.Info(String.Format("Media Items Minfier: Published item - '{0}' minified successfully.", item.Paths.FullPath), this);
}
catch (Exception ex)
{
Sitecore.Diagnostics.Log.Error(String.Format("Media Items Minfier: Published item - '{0}' not minified. Error: ", item.Paths.FullPath), ex, this);
}
}
}
}
}
/// <summary>
/// Minimizes the CSS code.
/// </summary>
/// <param name="inputCssFile">The input CSS file.</param>
/// <returns></returns>
public string MinimizeCssCode(string inputCssFile)
{
var cssContents = File.ReadAllText(this.RapContext.MapPath(inputCssFile));
var cssCompress = new CssCompressor();
return cssCompress.Compress(cssContents);
}
