public virtual ProjectBuilder Build(ProjectBuilder builder)
        {
            var files = GetFiles(FileFilter);

            using (var cache = new BuildCache())
            {
                var changedFiles = files.Where(file => !cache.Contains(file));
                Parallel.ForEach(changedFiles, path =>
                {
                    builder.WriteInfo($"{ResourceType} minify: {path}");

                    var text   = File.ReadAllText(path);
                    var result = Minify(text);

                    var outputPath = GetMinimizedFileName(path);
                    File.WriteAllText(outputPath, result);
                    cache.AddCache(path);

                    builder.WriteHint($"\t=> {outputPath}");
                    // builder.WriteHint($"\t=> {outputPath.PadRight(48)}{(100.0 * result.Length / text.Length):0.##}%");
                });
                cache.SaveCache();
            }
            files.ForEach(file =>
            {
                builder.OriginalResourceLength  += new FileInfo(file).Length;
                builder.MinimizedResourceLength += new FileInfo(GetMinimizedFileName(file)).Length;
            });
            builder.WriteSuccess($"{ResourceType} minify complete.");
            return(builder);
        }
Beispiel #2
0
        public ProjectBuilder BuildTypeScripts()
        {
            var tsc   = new TypeScriptCompiler();
            var files = ResourceMinifier.GetFiles(file =>
                                                  (file.FullName.Contains(@"style\") ||
                                                   file.FullName.Contains(@"touch\") ||
                                                   file.FullName.Contains(@"utils\") ||
                                                   file.FullName.Contains(@"video\")) &&
                                                  file.Extension == ".ts" &&
                                                  !file.Name.EndsWith(".d.ts")
                                                  );

            using (var cache = new BuildCache())
            {
                var changedFiles = files.Where(file => !cache.Contains(file)).ToArray();
                if (changedFiles.Any())
                {
                    changedFiles.ForEach(file =>
                    {
                        cache.AddCache(file);
                        WriteInfo($"TypeScript build: {file}");
                    });
                    Console.Write(tsc.Run().Trim());
                    changedFiles.ForEach(file =>
                    {
                        WriteHint($"\t=> {file.Replace(".ts", ".js")}");
                    });
                }
                cache.SaveCache();
            }
            WriteSuccess("TypeScript build complete.");
            return(this);
        }
Beispiel #3
0
        public ProjectBuilder BuildTypeScripts()
        {
            var tsc      = new TypeScriptCompiler();
            var uglifyJs = new JavascriptMinifier();
            var files    = ResourceMinifier.GetFiles(file =>
                                                     file.FullName.Contains(@"src\") &&
                                                     file.Extension == ".ts" &&
                                                     !file.Name.EndsWith(".d.ts")
                                                     );

            using (var cache = new BuildCache())
            {
                var changedFiles = files.Where(file => !cache.Contains(file)).ToArray();
                if (changedFiles.Any())
                {
                    changedFiles.ForEach(file =>
                    {
                        cache.AddCache(file);
                        WriteInfo($"TypeScript build: {file}");
                    });
                    Console.Write(tsc.Run().Trim());
                    Parallel.ForEach(changedFiles.Select(f => ".ts-output/" + f.Replace(".ts", ".js").Replace($"src{Path.DirectorySeparatorChar}", "")), file => {
                        var min     = uglifyJs.Minify(File.ReadAllText(file));
                        var minFile = ResourceMinifier.GetMinimizedFileName(file);
                        File.WriteAllText(minFile, min);
                        WriteHint($"\t=> {minFile}");
                    });
                }
                cache.SaveCache();
            }
            WriteSuccess("TypeScript build complete.");
            return(this);
        }
Beispiel #4
0
        public ProjectBuilder BuildSass()
        {
            var sass     = new SassCompiler();
            var cleancss = new CssMinifier();
            var files    = ResourceMinifier.GetFiles(file =>
                                                     file.FullName.Contains("src" + Path.DirectorySeparatorChar) &&
                                                     file.Extension == ".scss"
                                                     );

            using (var cache = new BuildCache())
            {
                var changedFiles = files.Where(file => !cache.Contains(file)).ToArray();
                if (changedFiles.Any())
                {
                    changedFiles.ForEach(file =>
                    {
                        cache.AddCache(file);
                        WriteInfo($"Sass build: {file}");
                    });
                    Console.Write(sass.Run().Trim());
                    var results = ResourceMinifier.GetFiles(f => f.FullName.Contains(".sass-output" + Path.DirectorySeparatorChar));
                    Parallel.ForEach(results, file =>
                    {
                        var min     = cleancss.Minify(File.ReadAllText(file).Replace("@charset \"UTF-8\";", ""));
                        var minFile = ResourceMinifier.GetMinimizedFileName(file);
                        File.WriteAllText(minFile, min);
                        // WriteHint($"\t=> {minFile}");
                    });
                }
                cache.SaveCache();
            }
            WriteSuccess("Sass build complete.");
            return(this);
        }
        public ProjectBuilder BuildSass()
        {
            var sass     = new SassCompiler();
            var cleancss = new CssMinifier();
            var files    = ResourceMinifier.GetFiles(file =>
                                                     file.Extension == ".scss"
                                                     );

            using (var cache = new BuildCache())
            {
                var changedFiles = files.Where(file => !cache.Contains(file)).ToArray();
                if (changedFiles.Any())
                {
                    string getOutputCacheFilename(string f)
                    {
                        return(".sass-output/" + f
                               .Replace(".scss", ".css")
                               .Replace($"src{Path.DirectorySeparatorChar}", ""));
                    }

                    changedFiles.ForEach(file => {
                        cache.AddCache(file);
                        WriteInfo($"Sass build: {file}");
                    });
                    WriteInfo(sass.Run("").Trim());
                    Parallel.ForEach(changedFiles
                                     .Where(f => !Path.GetFileName(f).StartsWith("_")),
                                     f => {
                        // var sass = new SassSingleCompiler();
                        // var css = sass.Run(File.ReadAllText(file));
                        // File.WriteAllText(getOutputCacheFilename(file), css);
                        var file    = getOutputCacheFilename(f);
                        var min     = cleancss.Minify(File.ReadAllText(file).Replace("@charset \"UTF-8\";", ""));
                        var minFile = ResourceMinifier.GetMinimizedFileName(file);
                        File.WriteAllText(minFile, min);
                        UpdateCachedMinFile(minFile);
                        // WriteHint($"\t=> {minFile}");
                    });
                    // var results = ResourceMinifier.GetFiles(f => f.FullName.Contains(".sass-output" + Path.DirectorySeparatorChar));
                    // Parallel.ForEach(results, file =>
                    // {
                    //   var min = cleancss.Minify(File.ReadAllText(file).Replace("@charset \"UTF-8\";", ""));
                    //   var minFile = ResourceMinifier.GetMinimizedFileName(file);
                    //   File.WriteAllText(minFile, min);
                    // });
                }
                cache.SaveCache();
            }
            WriteSuccess("Sass build complete.");
            return(this);
        }
        public ProjectBuilder BuildTypeScripts()
        {
            var tsc      = new BabelCompiler();
            var uglifyJs = new JavascriptMinifier();
            var files    = ResourceMinifier.GetFiles(file =>
                                                     file.Extension == ".ts" &&
                                                     !file.Name.EndsWith(".d.ts")
                                                     );

            using (var cache = new BuildCache())
            {
                var changedFiles = files.Where(file => !cache.Contains(file)).ToArray();
                if (changedFiles.Any())
                {
                    string getOutputCacheFilename(string f)
                    {
                        return(".ts-output/" + f
                               .Replace(".ts", ".js")
                               .Replace($"src{Path.DirectorySeparatorChar}", ""));
                    }

                    changedFiles.ForEach(file => {
                        cache.AddCache(file);
                        WriteInfo($"TypeScript build: {file}");
                    });
                    WriteInfo(tsc.Run("").Trim());
                    Parallel.ForEach(changedFiles
                                     .Where(f => !f.EndsWith(".vue.ts")),
                                     f => {
                        // var tsc = new BabelSingleCompiler(file);
                        // var js = tsc.Run(File.ReadAllText(file));
                        // File.WriteAllText(getOutputCacheFilename(file), js);
                        var file = getOutputCacheFilename(f);
                        var text = RegexReplacer.Replace(File.ReadAllText(file), @"import\(\(\(\)\s*=>\s*(.*)\)\(\)\)", match =>
                        {
                            return($"import({match.Groups[1].Value})");
                        });
                        var min     = uglifyJs.Minify(text);
                        var minFile = ResourceMinifier.GetMinimizedFileName(file);
                        File.WriteAllText(minFile, min);
                        UpdateCachedMinFile(minFile);
                        // WriteHint($"\t=> {minFile}");
                    });
                }
                cache.SaveCache();
            }
            WriteSuccess("TypeScript build complete.");
            return(this);
        }
Beispiel #7
0
        public ProjectBuilder BuildVue()
        {
            var files = ResourceMinifier.GetFiles(file =>
                                                  file.Extension == ".vue"
                                                  );

            using (var cache = new BuildCache())
            {
                var changedFiles = files.Where(file => !cache.Contains(file)).ToArray();
                if (changedFiles.Any())
                {
                    Parallel.ForEach(changedFiles, file =>
                    {
                        cache.AddCache(file);
                        WriteInfo($"Vue build: {file}");
                        var source       = File.ReadAllText(file);
                        var vueFile      = new VueFile(source);
                        var compiledText = new StringBuilder("");
                        if (vueFile.Tamplate is null)
                        {
                            throw new VueBuildException($"{file}: Missing <tamplate>");
                        }
                        else
                        {
                            var uglifyHtml = new UglifyHtml();
                            if (vueFile.TamplateLang == "html")
                            {
                                compiledText.Append($"const template = /*html*/`{uglifyHtml.Run(vueFile.Tamplate)}`;");
                            }
                            else
                            {
                                throw new VueBuildException($"{file}: Unsupported <template> lang '{vueFile.TamplateLang}'");
                            }
                        }
                        if (vueFile.Style != null)
                        {
                            var styleID   = Path.ChangeExtension(Path.GetFileName(file), null).Replace(".", "-") + "-style";
                            var uglifyCss = new UglifyCss();
                            if (vueFile.StyleLang == "css")
                            {
                                compiledText.Append($"resources.applyStyleFromText(`{uglifyCss.Run(vueFile.Style)}`,'{styleID}');");
                            }
                            else if (vueFile.StyleLang == "scss")
                            {
                                var sass = new SassSingleCompiler();
                                var css  = uglifyCss.Run(sass.Run(vueFile.Style).Replace("@charset \"UTF-8\";", ""));
                                compiledText.Append($"resources.applyStyleFromText(`{css}`,'{styleID}');");
                            }
                            else
                            {
                                throw new VueBuildException($"{file}: Unsupported <style> lang '{vueFile.StyleLang}'");
                            }
                        }
                        if (vueFile.Script is null)
                        {
                            throw new VueBuildException($"{file}: Missing <script>");
                        }
                        else
                        {
                            if (vueFile.ScriptLang == "js" || vueFile.ScriptLang == "javascript")
                            {
                                var script = vueFile.Script.Replace("export default ", "return {export:Object.assign({template},").Trim().TrimEnd(';');
                                compiledText.Append($"{script})}}");
                            }
                            else if (vueFile.ScriptLang == "ts" || vueFile.ScriptLang == "typescript")
                            {
                                var tsFile = file + ".ts";
                                var jsFile = ".ts-output" + Path.DirectorySeparatorChar + file.Replace("src" + Path.DirectorySeparatorChar, "") + ".js";
                                var script = File.ReadAllText(jsFile).Replace("export default ", "return {export:Object.assign({template},").Trim().TrimEnd(';');
                                compiledText.Append($"{script})}}");
                                File.Delete(tsFile);
                                // File.Delete(jsFile);
                            }
                            else
                            {
                                throw new VueBuildException($"{file}: Unsupported <script> lang '{vueFile.ScriptLang}'");
                            }
                        }
                        // compiledText.Append("}})()");
                        var minFile = "min" + Path.DirectorySeparatorChar + Path.GetFileName(file) + ".min.js";
                        var jsc     = new JavascriptMinifier();
                        File.WriteAllText(minFile, jsc.Minify(compiledText.ToString()));
                        UpdateCachedMinFile(minFile);
                        WriteHint($"\t=> {minFile}");
                    });
                }
                cache.SaveCache();
            }
            WriteSuccess("Vue build complete.");
            return(this);
        }