/// <summary>
/// Minifies a JavaScript File into a Minified JavaScript File
/// </summary>
/// <param name="InputFileName"></param>
/// <param name="OutputFileName"></param>
/// <returns></returns>
public bool MinifyFile(string InputFileName, string OutputFileName)
{
try
{
this.FilesProcessed = 0;
JavaScriptMinifier min = new JavaScriptMinifier();
min.Minify(InputFileName, OutputFileName);
Stream file = File.OpenRead(InputFileName);
this.InputSize = (int)file.Length;
file.Close();
file = File.OpenRead(OutputFileName);
this.OutputSize = (int)file.Length;
file.Close();
this.FilesProcessed = 1;
}
catch (Exception ex)
{
this.ErrorMessage = ex.Message;
return(false);
}
finally
{
}
return(true);
}
/// <summary>
/// Minifies all JavaScript files in a given directory and writes out the
/// minified files to a new file extensions (.min.js for example).
///
/// This method can be integrated into the build process, or as part of an
/// application's startup to always create new minified scripts as needed.
/// Scripts are only minified if the minified files don't already exist and are
/// older than the corresponding JavaScript file.
///
/// A common usage scenario is to call this static method from
/// Application_Start:
///
/// <<code lang="C#">>void Application_Start(object sender,
/// EventArgs e)
/// {
/// // creates minify scripts if don't exist or are changed
/// // NOTE: REQUIRES that IIS/ASP.NET Account has writes to write
/// here!
///
/// Westwind.Web.Controls.JavaScriptMinifier.MinifyDirectory(Server.MapPath("~/
/// scripts"), ".min.js", true);
/// }<</code>>
///
/// to always ensure minified files are in sync with corresponding JavaScript
/// files.
/// <seealso>Class JavaScriptMinifier </seealso>
/// </summary>
/// <param name="path">
/// The path where files are to be minfied
/// </param>
/// <param name="minExtension">
/// The extension for the minified files (ie. .min.js). Include leading dot!
/// </param>
/// <param name="recursive">
/// Determines whether nested directories are also included
/// </param>
/// <remarks>
/// Note that if you use this script from within an ASP.NET application it's
/// best to hook it to a Application_Start or a static constructor so it only
/// fires once.
///
/// When called from ASP.NET this routine REQUIRES that the server account that
/// ASP.NET/IIS AppPool runs under (NETWORK SERVICE by default) has rights to
/// write out the file to the folder specified. Otherwise an exception occurs.
/// </remarks>
public static void MinifyDirectory(string path, string minExtension, bool recursive)
{
JavaScriptMinifier min = new JavaScriptMinifier();
minExtension = minExtension.ToLower();
if (!minExtension.StartsWith("."))
{
minExtension = "." + minExtension;
}
string[] files = null;
try
{
files = Directory.GetFiles(path);
}
catch
{
throw new InvalidOperationException("Invalid or inaccessible path to create Min Scripts in: " + path);
}
try
{
foreach (string file in files)
{
string extension = Path.GetExtension(file).ToLower();
if (extension == ".js" && !file.EndsWith(minExtension))
{
string minFile = file.Replace(".js", minExtension);
DateTime fileAT = File.GetLastWriteTimeUtc(file);
DateTime minFileAT = File.GetLastWriteTimeUtc(minFile);
if (!File.Exists(minFile) || fileAT > minFileAT)
{
min.Minify(file, file.Replace(".js", minExtension));
}
}
}
if (recursive)
{
string[] dirs = Directory.GetDirectories(path);
foreach (string dir in dirs)
{
if (!dir.StartsWith("."))
{
MinifyDirectory(dir, minExtension, true);
}
}
}
}
catch
{
throw new AccessViolationException("Couldn't create Min Scripts in: " + path + ". Make sure ASP.NET has permissions to write in this path.");
}
}
public bool MinifyBatch()
{
try
{
this.FilesProcessed = 0;
JavaScriptMinifier min = new JavaScriptMinifier();
string scriptPath = Path.GetDirectoryName(this.InputFile);
string renameTo = ".min.js";
if (!string.IsNullOrEmpty(this.OutputFile) && this.OutputFile.StartsWith("."))
{
renameTo = this.OutputFile.ToLower();
}
int TotalInputSize = 0;
int TotalOutputSize = 0;
string[] scriptFiles = Directory.GetFiles(scriptPath, "*.js");
foreach (string file in scriptFiles)
{
string scriptFile = file.ToLower();
// Skip VS Intellisense files
if (scriptFile.Contains("-vsdoc"))
{
continue;
}
if (scriptFile.EndsWith(renameTo))
{
continue;
}
this.MinifyFile(scriptFile, scriptFile.Replace(".js", renameTo));
this.FilesProcessed++;
TotalInputSize += this.InputSize;
TotalOutputSize += this.OutputSize;
}
this.InputSize = TotalInputSize;
this.OutputSize = TotalOutputSize;
}
catch (Exception ex)
{
this.ErrorMessage = ex.Message;
return(false);
}
return(true);
}
/// <summary>
/// Minifies the inputFile and generates a .min.js file of the same name
/// </summary>
/// <param name="InputFileName"></param>
/// <returns></returns>
public bool MinifyFile(string InputFileName)
{
try
{
string OutputFileName = GetOutputFile(InputFileName);
JavaScriptMinifier min = new JavaScriptMinifier();
min.Minify(InputFileName, OutputFileName);
}
catch (Exception ex)
{
this.ErrorMessage = ex.Message;
return(false);
}
return(true);
}
/// <summary>
/// Minifies a JavaScript string into a minified JavaScript string
/// </summary>
/// <param name="InputString"></param>
/// <returns></returns>
public string MinifyString(string InputString)
{
try
{
this.FilesProcessed = 0;
this.InputSize = InputString.Length;
JavaScriptMinifier min = new JavaScriptMinifier();
this.OutputText = min.MinifyString(InputString);
this.OutputSize = this.OutputText.Length;
this.FilesProcessed = 1;
return(this.OutputText);
}
catch (Exception ex)
{
this.ErrorMessage = ex.Message;
return(null);
}
}
/// <summary>
/// Minifies JavaScript content based on the properties of this class.
/// Takes file input and minifies into OutputFile if set and OutputText
/// </summary>
/// <returns>true or false</returns>
public bool MiniFy()
{
try
{
this.FilesProcessed = 0;
JavaScriptMinifier min = new JavaScriptMinifier();
if (this.InputFile.ToLower().Contains("*.js"))
{
return(this.MinifyBatch());
}
bool result = this.MinifyFile(this.InputFile, this.OutputFile);
if (!result)
{
return(false);
}
if (!string.IsNullOrEmpty(this.OutputFile))
{
StreamReader sr = StringUtilities.OpenStreamReaderWithEncoding(this.OutputFile);
this.OutputText = sr.ReadToEnd();
sr.Close();
this.OutputSize = this.OutputText.Length;
}
this.FilesProcessed = 1;
}
catch (Exception ex)
{
this.ErrorMessage = ex.Message;
return(false);
}
return(true);
}
