Ejemplo n.º 1
0
        private void InnerMinify(IAsset asset, JsPacker jsPacker)
        {
            string newContent;
            string assetUrl = asset.Url;

            try
            {
                newContent = jsPacker.Pack(asset.Content);
            }
            catch (JsPackingException e)
            {
                throw new AssetMinificationException(
                          string.Format(CoreStrings.Minifiers_MinificationSyntaxError,
                                        CODE_TYPE, assetUrl, MINIFIER_NAME, e.Message));
            }
            catch (Exception e)
            {
                throw new AssetMinificationException(
                          string.Format(CoreStrings.Minifiers_MinificationFailed,
                                        CODE_TYPE, assetUrl, MINIFIER_NAME, e.Message));
            }

            asset.Content  = newContent;
            asset.Minified = true;
        }
Ejemplo n.º 2
0
        /// <summary>
        /// Produces a code minifiction of JS assets by using Dean Edwards' Packer
        /// </summary>
        /// <param name="assets">Set of JS assets</param>
        /// <returns>Set of JS assets with minified text content</returns>
        public IList <IAsset> Minify(IList <IAsset> assets)
        {
            if (assets == null)
            {
                throw new ArgumentNullException(
                          nameof(assets),
                          string.Format(CoreStrings.Common_ArgumentIsNull, nameof(assets))
                          );
            }

            if (assets.Count == 0)
            {
                return(assets);
            }

            var assetsToProcessing = assets.Where(a => a.IsScript && !a.Minified).ToList();

            if (assetsToProcessing.Count == 0)
            {
                return(assets);
            }

            PackingOptions options = CreatePackingOptions();

            using (var jsPacker = new JsPacker(_createJsEngineInstance, options))
            {
                foreach (var asset in assetsToProcessing)
                {
                    InnerMinify(asset, jsPacker);
                }
            }

            return(assets);
        }
        /// <summary>
        /// Produces a code minifiction of JS asset by using Dean Edwards' Packer
        /// </summary>
        /// <param name="asset">JS asset</param>
        /// <returns>JS asset with minified text content</returns>
        public IAsset Minify(IAsset asset)
        {
            if (asset == null)
            {
                throw new ArgumentException(CoreStrings.Common_ValueIsEmpty, "asset");
            }

            if (asset.Minified)
            {
                return(asset);
            }

            PackingOptions options = CreatePackingOptions();

            using (var jsPacker = new JsPacker(_createJsEngineInstance, options))
            {
                InnerMinify(asset, jsPacker);
            }

            return(asset);
        }
Ejemplo n.º 4
0
        /// <summary>
        /// Produces a code minifiction of JS asset by using Dean Edwards' Packer
        /// </summary>
        /// <param name="asset">JS asset</param>
        /// <returns>JS asset with minified text content</returns>
        public IAsset Minify(IAsset asset)
        {
            if (asset == null)
            {
                throw new ArgumentNullException(
                          nameof(asset),
                          string.Format(CoreStrings.Common_ArgumentIsNull, nameof(asset))
                          );
            }

            if (asset.Minified)
            {
                return(asset);
            }

            PackingOptions options = CreatePackingOptions();

            using (var jsPacker = new JsPacker(_createJsEngineInstance, options))
            {
                InnerMinify(asset, jsPacker);
            }

            return(asset);
        }
        private void InnerMinify(IAsset asset, JsPacker jsPacker, bool shrinkVariables, bool base62Encode)
        {
            string newContent;
            string assetVirtualPath = asset.VirtualPath;

            try
            {
                newContent = jsPacker.Pack(asset.Content, base62Encode, shrinkVariables);
            }
            catch (JsPackingException e)
            {
                throw new AssetMinificationException(
                    string.Format(CoreStrings.Minifiers_MinificationSyntaxError,
                        CODE_TYPE, assetVirtualPath, MINIFIER_NAME, e.Message));
            }
            catch (Exception e)
            {
                throw new AssetMinificationException(
                    string.Format(CoreStrings.Minifiers_MinificationFailed,
                        CODE_TYPE, assetVirtualPath, MINIFIER_NAME, e.Message));
            }

            asset.Content = newContent;
            asset.Minified = true;
        }
        /// <summary>
        /// Produces a code minifiction of JS-assets by using Dean Edwards' Packer
        /// </summary>
        /// <param name="assets">Set of JS-assets</param>
        /// <returns>Set of JS-assets with minified text content</returns>
        public IList<IAsset> Minify(IList<IAsset> assets)
        {
            if (assets == null)
            {
                throw new ArgumentException(CoreStrings.Common_ValueIsEmpty, "assets");
            }

            if (assets.Count == 0)
            {
                return assets;
            }

            var assetsToProcessing = assets.Where(a => a.IsScript && !a.Minified).ToList();
            if (assetsToProcessing.Count == 0)
            {
                return assets;
            }

            bool shrinkVariables = ShrinkVariables;
            bool base62Encode = Base62Encode;

            using (var jsPacker = new JsPacker(_createJsEngineInstance))
            {
                foreach (var asset in assetsToProcessing)
                {
                    InnerMinify(asset, jsPacker, shrinkVariables, base62Encode);
                }
            }

            return assets;
        }
        /// <summary>
        /// Produces a code minifiction of JS-asset by using Dean Edwards' Packer
        /// </summary>
        /// <param name="asset">JS-asset</param>
        /// <returns>JS-asset with minified text content</returns>
        public IAsset Minify(IAsset asset)
        {
            if (asset == null)
            {
                throw new ArgumentException(CoreStrings.Common_ValueIsEmpty, "asset");
            }

            if (asset.Minified)
            {
                return asset;
            }

            using (var jsPacker = new JsPacker(_createJsEngineInstance))
            {
                InnerMinify(asset, jsPacker, ShrinkVariables, Base62Encode);
            }

            return asset;
        }