first commit

build/node_modules/postcss-discard-unused/dist/index.js

@@ -0,0 +1,162 @@
+'use strict';
+
+exports.__esModule = true;
+
+var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
+
+var _uniqs = require('uniqs');
+
+var _uniqs2 = _interopRequireDefault(_uniqs);
+
+var _postcss = require('postcss');
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var comma = _postcss.list.comma;
+var space = _postcss.list.space;
+
+
+var atrule = 'atrule';
+var decl = 'decl';
+var rule = 'rule';
+
+function addValues(cache, _ref) {
+    var value = _ref.value;
+
+    return comma(value).reduce(function (memo, val) {
+        return [].concat(memo, space(val));
+    }, cache);
+}
+
+function filterAtRule(_ref2) {
+    var atRules = _ref2.atRules;
+    var values = _ref2.values;
+
+    values = (0, _uniqs2.default)(values);
+    atRules.forEach(function (node) {
+        var hasAtRule = values.some(function (value) {
+            return value === node.params;
+        });
+        if (!hasAtRule) {
+            node.remove();
+        }
+    });
+}
+
+function filterNamespace(_ref3) {
+    var atRules = _ref3.atRules;
+    var rules = _ref3.rules;
+
+    rules = (0, _uniqs2.default)(rules);
+    atRules.forEach(function (atRule) {
+        var _atRule$params$split$ = atRule.params.split(' ').filter(Boolean);
+
+        var param = _atRule$params$split$[0];
+        var len = _atRule$params$split$.length;
+
+        if (len === 1) {
+            return;
+        }
+        var hasRule = rules.some(function (r) {
+            return r === param || r === '*';
+        });
+        if (!hasRule) {
+            atRule.remove();
+        }
+    });
+}
+
+function hasFont(fontFamily, cache) {
+    return comma(fontFamily).some(function (font) {
+        return cache.some(function (c) {
+            return ~c.indexOf(font);
+        });
+    });
+}
+
+// fonts have slightly different logic
+function filterFont(_ref4) {
+    var atRules = _ref4.atRules;
+    var values = _ref4.values;
+
+    values = (0, _uniqs2.default)(values);
+    atRules.forEach(function (r) {
+        var families = r.nodes.filter(function (_ref5) {
+            var prop = _ref5.prop;
+            return prop === 'font-family';
+        });
+        // Discard the @font-face if it has no font-family
+        if (!families.length) {
+            return r.remove();
+        }
+        families.forEach(function (family) {
+            if (!hasFont(family.value.toLowerCase(), values)) {
+                r.remove();
+            }
+        });
+    });
+}
+
+exports.default = (0, _postcss.plugin)('postcss-discard-unused', function (opts) {
+    var _fontFace$counterStyl = _extends({
+        fontFace: true,
+        counterStyle: true,
+        keyframes: true,
+        namespace: true
+    }, opts);
+
+    var fontFace = _fontFace$counterStyl.fontFace;
+    var counterStyle = _fontFace$counterStyl.counterStyle;
+    var keyframes = _fontFace$counterStyl.keyframes;
+    var namespace = _fontFace$counterStyl.namespace;
+
+    return function (css) {
+        var counterStyleCache = { atRules: [], values: [] };
+        var keyframesCache = { atRules: [], values: [] };
+        var namespaceCache = { atRules: [], rules: [] };
+        var fontCache = { atRules: [], values: [] };
+        css.walk(function (node) {
+            var type = node.type;
+            var prop = node.prop;
+            var selector = node.selector;
+            var name = node.name;
+
+            if (type === rule && namespace && ~selector.indexOf('|')) {
+                namespaceCache.rules = namespaceCache.rules.concat(selector.split('|')[0]);
+                return;
+            }
+            if (type === decl) {
+                if (counterStyle && /list-style|system/.test(prop)) {
+                    counterStyleCache.values = addValues(counterStyleCache.values, node);
+                }
+                if (fontFace && node.parent.type === rule && /font(|-family)/.test(prop)) {
+                    fontCache.values = fontCache.values.concat(comma(node.value.toLowerCase()));
+                }
+                if (keyframes && /animation/.test(prop)) {
+                    keyframesCache.values = addValues(keyframesCache.values, node);
+                }
+                return;
+            }
+            if (type === atrule) {
+                if (counterStyle && /counter-style/.test(name)) {
+                    counterStyleCache.atRules.push(node);
+                }
+                if (fontFace && name === 'font-face' && node.nodes) {
+                    fontCache.atRules.push(node);
+                }
+                if (keyframes && /keyframes/.test(name)) {
+                    keyframesCache.atRules.push(node);
+                }
+                if (namespace && name === 'namespace') {
+                    namespaceCache.atRules.push(node);
+                }
+                return;
+            }
+        });
+        counterStyle && filterAtRule(counterStyleCache);
+        fontFace && filterFont(fontCache);
+        keyframes && filterAtRule(keyframesCache);
+        namespace && filterNamespace(namespaceCache);
+    };
+});
+module.exports = exports['default'];