style Dashboard

node_modules/csso/lib/compressor/clean/Atrule.js

@@ -0,0 +1,54 @@
+module.exports = function cleanAtrule(node, item, list) {
+    if (node.block) {
+        // otherwise removed at-rule don't prevent @import for removal
+        this.root.firstAtrulesAllowed = false;
+
+        if (node.block.type === 'Block' && node.block.declarations.isEmpty()) {
+            list.remove(item);
+            return;
+        }
+
+        if (node.block.type === 'StyleSheet' && node.block.rules.isEmpty()) {
+            list.remove(item);
+            return;
+        }
+    }
+
+    switch (node.name) {
+        case 'charset':
+            if (node.expression.sequence.isEmpty()) {
+                list.remove(item);
+                return;
+            }
+
+            // if there is any rule before @charset -> remove it
+            if (item.prev) {
+                list.remove(item);
+                return;
+            }
+
+            break;
+
+        case 'import':
+            if (!this.root.firstAtrulesAllowed) {
+                list.remove(item);
+                return;
+            }
+
+            // if there are some rules that not an @import or @charset before @import
+            // remove it
+            list.prevUntil(item.prev, function(rule) {
+                if (rule.type === 'Atrule') {
+                    if (rule.name === 'import' || rule.name === 'charset') {
+                        return;
+                    }
+                }
+
+                this.root.firstAtrulesAllowed = false;
+                list.remove(item);
+                return true;
+            }, this);
+
+            break;
+    }
+};

node_modules/csso/lib/compressor/clean/Comment.js

@@ -0,0 +1,3 @@
+module.exports = function cleanComment(data, item, list) {
+    list.remove(item);
+};

node_modules/csso/lib/compressor/clean/Declaration.js

@@ -0,0 +1,5 @@
+module.exports = function cleanDeclartion(node, item, list) {
+    if (node.value.sequence.isEmpty()) {
+        list.remove(item);
+    }
+};

node_modules/csso/lib/compressor/clean/Identifier.js

@@ -0,0 +1,9 @@
+module.exports = function cleanIdentifier(node, item, list) {
+    // remove useless universal selector
+    if (this.selector !== null && node.name === '*') {
+        // remove when universal selector isn't last
+        if (item.next && item.next.data.type !== 'Combinator') {
+            list.remove(item);
+        }
+    }
+};

node_modules/csso/lib/compressor/clean/Ruleset.js

@@ -0,0 +1,39 @@
+var hasOwnProperty = Object.prototype.hasOwnProperty;
+
+function cleanUnused(node, usageData) {
+    return node.selector.selectors.each(function(selector, item, list) {
+        var hasUnused = selector.sequence.some(function(node) {
+            switch (node.type) {
+                case 'Class':
+                    return usageData.classes && !hasOwnProperty.call(usageData.classes, node.name);
+
+                case 'Id':
+                    return usageData.ids && !hasOwnProperty.call(usageData.ids, node.name);
+
+                case 'Identifier':
+                    // ignore universal selector
+                    if (node.name !== '*') {
+                        // TODO: remove toLowerCase when type selectors will be normalized
+                        return usageData.tags && !hasOwnProperty.call(usageData.tags, node.name.toLowerCase());
+                    }
+
+                    break;
+            }
+        });
+
+        if (hasUnused) {
+            list.remove(item);
+        }
+    });
+}
+
+module.exports = function cleanRuleset(node, item, list, usageData) {
+    if (usageData) {
+        cleanUnused(node, usageData);
+    }
+
+    if (node.selector.selectors.isEmpty() ||
+        node.block.declarations.isEmpty()) {
+        list.remove(item);
+    }
+};

node_modules/csso/lib/compressor/clean/Space.js

@@ -0,0 +1,16 @@
+function canCleanWhitespace(node) {
+    if (node.type !== 'Operator') {
+        return false;
+    }
+
+    return node.value !== '+' && node.value !== '-';
+}
+
+module.exports = function cleanWhitespace(node, item, list) {
+    var prev = item.prev && item.prev.data;
+    var next = item.next && item.next.data;
+
+    if (canCleanWhitespace(prev) || canCleanWhitespace(next)) {
+        list.remove(item);
+    }
+};

node_modules/csso/lib/compressor/clean/index.js

@@ -0,0 +1,17 @@
+var walk = require('../../utils/walk.js').all;
+var handlers = {
+    Space: require('./Space.js'),
+    Atrule: require('./Atrule.js'),
+    Ruleset: require('./Ruleset.js'),
+    Declaration: require('./Declaration.js'),
+    Identifier: require('./Identifier.js'),
+    Comment: require('./Comment.js')
+};
+
+module.exports = function(ast, usageData) {
+    walk(ast, function(node, item, list) {
+        if (handlers.hasOwnProperty(node.type)) {
+            handlers[node.type].call(this, node, item, list, usageData);
+        }
+    });
+};