Ejemplo n.º 1
0
        public static String GenerateTemplate(string v)
        {
            var min = new   WebMarkupMin.Core.HtmlMinifier(new WebMarkupMin.Core.HtmlMinificationSettings()
            {
                RemoveCdataSectionsFromScriptsAndStyles = false,
                UseShortDoctype            = false,
                PreserveCase               = false,
                UseMetaCharsetTag          = false,
                EmptyTagRenderMode         = WebMarkupMin.Core.HtmlEmptyTagRenderMode.NoSlash,
                RemoveOptionalEndTags      = false,
                CollapseBooleanAttributes  = false,
                AttributeQuotesRemovalMode = WebMarkupMin.Core.HtmlAttributeQuotesRemovalMode.KeepQuotes,
                RemoveJsTypeAttributes     = false,
                RemoveCssTypeAttributes    = false
            });

            v = min.Minify(v).MinifiedContent;
            var sb      = new StringBuilder();
            var array   = Regex.Split(v, "{{[^}]*?}}");
            var matches = Regex.Matches(v, "{{([^}]*?)}}").Cast <Match>().Select(i => i.Groups[1].Value).ToArray();
            var index   = 0;

            foreach (var item in array)
            {
                sb.Append("\"" + item.Trim().Replace("\"", "\\\"") + "\"").Append('+').AppendLine().Append(index < matches.Length ? matches[index] : "").Append('+');
                index++;
            }
            return(Regex.Replace(sb.ToString(), "[\\s\\+]+$", "") + ";");
        }
 public void WebMarkupMin()
 {
     var settings = new WmmSettings
     {
         MinifyEmbeddedCssCode = false,
         MinifyInlineCssCode   = false,
         MinifyEmbeddedJsCode  = false,
         MinifyInlineJsCode    = false
     };
     var    minifier        = new WmmMinifier(settings, new WmmNullCssMinifier(), new WmmNullJsMinifier());
     string minifiedContent = minifier.Minify(s_documents[DocumentName].Content).MinifiedContent;
 }
Ejemplo n.º 3
0
        private static string MinifyHtml(string value)
        {
            // https://github.com/JadeX/JadeX.HtmlMinifier/blob/c6617d602eedc31d90a8637cbb7d32006f48605c/Filters/MinifyHtmlFilter.cs
            var m = new WebMarkupMin.Core.HtmlMinifier(
                new WebMarkupMin.Core.HtmlMinificationSettings {
                AttributeQuotesRemovalMode = WebMarkupMin.Core.HtmlAttributeQuotesRemovalMode.KeepQuotes,
                RemoveTagsWithoutContent   = false,
                EmptyTagRenderMode         = WebMarkupMin.Core.HtmlEmptyTagRenderMode.Slash,
            }
                );

            return(m.Minify(value).MinifiedContent);
        }
Ejemplo n.º 4
0
 void 压缩ToolStripMenuItemClick(object sender, EventArgs e)
 {
     OnClipboardString(s => {
         var min = new   WebMarkupMin.Core.HtmlMinifier(new WebMarkupMin.Core.HtmlMinificationSettings()
         {
             RemoveCdataSectionsFromScriptsAndStyles = false,
             UseShortDoctype            = false,
             PreserveCase               = false,
             UseMetaCharsetTag          = false,
             EmptyTagRenderMode         = WebMarkupMin.Core.HtmlEmptyTagRenderMode.NoSlash,
             RemoveOptionalEndTags      = false,
             CollapseBooleanAttributes  = false,
             AttributeQuotesRemovalMode = WebMarkupMin.Core.HtmlAttributeQuotesRemovalMode.KeepQuotes,
             RemoveJsTypeAttributes     = false,
             RemoveCssTypeAttributes    = false
         });
         return(min.Minify(s).MinifiedContent);
     });
 }
Ejemplo n.º 5
0
        private static Dictionary <string, Tuple <string, byte[]> > LoadCache(string basePath, string[] extensions = null)
        {
            //put static files minificated in a memory store -> cache
            var staticFilesStorage = new Dictionary <string, Tuple <string, byte[]> >();
            //read all static files and load into mmemory
            var files = Directory.GetFiles(basePath, "*", SearchOption.AllDirectories).ToList();

            if (extensions != null)
            {
                files = files.Where(f => extensions.Contains(Path.GetExtension(f))).ToList();
            }
            var minifyJs   = new WebMarkupMin.Core.CrockfordJsMinifier();
            var minifyCss  = new WebMarkupMin.Core.KristensenCssMinifier();
            var minifyHtml = new WebMarkupMin.Core.HtmlMinifier();

            files.ForEach(file =>
            {
                var content = File.ReadAllBytes(file);
                var ext     = Path.GetExtension(file);
                //compress or minify
                if (Environment.GetEnvironmentVariable("minifyResponse") != "false")
                {
                    switch (ext)
                    {
                    case ".js":
                        //javascript minify
                        var js         = System.Text.UTF8Encoding.Default.GetString(content);
                        var minifiedJs = minifyJs.Minify(js, false);
                        if (!minifiedJs.Errors.Any())
                        {
                            content = System.Text.UTF8Encoding.Default.GetBytes(minifiedJs.MinifiedContent);
                        }
                        break;

                    case ".css":
                        //css minify
                        var css         = System.Text.UTF8Encoding.Default.GetString(content);
                        var minifiedCss = minifyCss.Minify(css, false);
                        if (!minifiedCss.Errors.Any())
                        {
                            content = System.Text.UTF8Encoding.Default.GetBytes(minifiedCss.MinifiedContent);
                        }
                        break;

                    case ".html":
                        //html minify
                        var html         = System.Text.UTF8Encoding.Default.GetString(content);
                        var minifiedHtml = minifyHtml.Minify(html, false);
                        if (!minifiedHtml.Errors.Any())
                        {
                            content = System.Text.UTF8Encoding.Default.GetBytes(minifiedHtml.MinifiedContent);
                        }
                        break;
                    }
                }
                staticFilesStorage.Add(file, new Tuple <string, byte[]>(MimeMapping.MimeUtility.GetMimeMapping(file), content));
            });

            var usedMemory = Math.Round(staticFilesStorage.Select(s => s.Value).Sum(s => s.Item2.Length) / 1024.0 / 1024.0);

            Console.WriteLine($"{staticFilesStorage.Count} static files loaded into memory using {usedMemory} MB");
            return(staticFilesStorage);
        }
Ejemplo n.º 6
0
        public static void Run(
            AbsolutePath scriptsDirectory,
            AbsolutePath componentsDirectory,
            string bundleFileName)
        {
            var componentsFolderPath    = componentsDirectory;
            var componentsPathForBundle = GetRelativePath(scriptsDirectory, componentsDirectory).Replace('\\', '/').Trim('/');
            var componentsFolder        = new DirectoryInfo(componentsFolderPath);

            var jsMinifier   = new WebMarkupMin.Core.CrockfordJsMinifier();
            var htmlMinifier = new WebMarkupMin.Core.HtmlMinifier(jsMinifier: jsMinifier);

            var bundleParts = componentsFolder.EnumerateDirectories().SelectMany(x =>
                                                                                 x.EnumerateFiles().Select(y =>
            {
                var name        = y.Name.Replace(y.Extension, string.Empty);
                var path        = string.Empty;
                var contentType = ContentType.Unknown;
                var content     = string.Empty;

                if (string.Equals(y.Extension, ".js", StringComparison.InvariantCultureIgnoreCase))
                {
                    path        = $"{componentsPathForBundle}/{x.Name}/{name}";
                    contentType = ContentType.Js;
                }
                else if (string.Equals(y.Extension, ".html", StringComparison.InvariantCultureIgnoreCase))
                {
                    path        = $"text!{componentsPathForBundle}/{x.Name}/{y.Name}";
                    contentType = ContentType.Html;
                }
                else
                {
                    return(ContentType: contentType, ModuleName: x.Name, ContentPath: y.FullName, Content: string.Empty);
                }

                using (var stream = File.OpenRead(y.FullName))
                    using (var reader = new StreamReader(stream))
                    {
                        content = reader.ReadToEnd();
                        switch (contentType)
                        {
                        case ContentType.Js:
                            content = jsMinifier.Minify(content, false).MinifiedContent;
                            break;

                        case ContentType.Html:
                            content = htmlMinifier.Minify(content).MinifiedContent.Replace("\r", "").Replace("\n", "").Replace("\'", "\\'");
                            break;

                        default:
                            break;
                        }
                    }
                return(ContentType: contentType, ModuleName: x.Name, ContentPath: path.Replace("\\", "/"), Content: content);
            })).ToList();

            var part1 = string.Join(string.Empty, bundleParts.SelectMany(x => x.ContentType == ContentType.Html ? new[] { $"define('{x.ContentPath}', [], function () {{ return '{x.Content}';}});" } : new string[] { }));
            var part2 = string.Join(string.Empty, bundleParts.SelectMany(x => x.ContentType == ContentType.Js ? new[] { x.Content } : new string[] { }));
            var moduleDescriptions = bundleParts.GroupBy(x => x.ModuleName);
            var part3 = $"define('components', [{string.Join(",", moduleDescriptions.Select(x => "'" + x.Key + "'"))}]);";
            var part4 = string.Join(string.Empty, moduleDescriptions.Select(x => $"define('{x.Key}', [{string.Join(",", x.Select(y => "'" + y.ContentPath + "'"))}]);"));

            using (var stream = File.Create(componentsFolderPath / bundleFileName))
                using (var writer = new StreamWriter(stream))
                {
                    writer.Write(string.Join(Environment.NewLine, new[] { part1, part2, part3, part4 }));
                }
            Console.WriteLine("Bundle assembled!");
        }