C# Minifier.MinifyJavaScript方法代码示例

 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 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);
        }

        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);
        }

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

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

	    /// <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 string Minify(string content)
        {
            var minifer = new Minifier();
            codeSettings = codeSettings ?? new CodeSettings();
            codeSettings.SetKnownGlobalNames(globalNames);

            return minifer.MinifyJavaScript(content, codeSettings);
        }

 protected override string Compress(string source)
 {
     var minifier = new Minifier();
     var minified = minifier.MinifyJavaScript(source);
     if (minifier.Errors.Count > 0)
     {
         return source;
     }
     return minified;
 }

        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);
        }

 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 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();
        }