less 3.10.0-beta.2 → 3.10.3

package/lib/less/visitors/import-visitor.js

@@ -0,0 +1,189 @@
+import contexts from '../contexts';
+import Visitor from './visitor';
+import ImportSequencer from './import-sequencer';
+import * as utils from '../utils';
+
+const ImportVisitor = function(importer, finish) {
+
+    this._visitor = new Visitor(this);
+    this._importer = importer;
+    this._finish = finish;
+    this.context = new contexts.Eval();
+    this.importCount = 0;
+    this.onceFileDetectionMap = {};
+    this.recursionDetector = {};
+    this._sequencer = new ImportSequencer(this._onSequencerEmpty.bind(this));
+};
+
+ImportVisitor.prototype = {
+    isReplacing: false,
+    run: function (root) {
+        try {
+            // process the contents
+            this._visitor.visit(root);
+        }
+        catch (e) {
+            this.error = e;
+        }
+
+        this.isFinished = true;
+        this._sequencer.tryRun();
+    },
+    _onSequencerEmpty: function() {
+        if (!this.isFinished) {
+            return;
+        }
+        this._finish(this.error);
+    },
+    visitImport: function (importNode, visitArgs) {
+        const inlineCSS = importNode.options.inline;
+
+        if (!importNode.css || inlineCSS) {
+
+            const context = new contexts.Eval(this.context, utils.copyArray(this.context.frames));
+            const importParent = context.frames[0];
+
+            this.importCount++;
+            if (importNode.isVariableImport()) {
+                this._sequencer.addVariableImport(this.processImportNode.bind(this, importNode, context, importParent));
+            } else {
+                this.processImportNode(importNode, context, importParent);
+            }
+        }
+        visitArgs.visitDeeper = false;
+    },
+    processImportNode: function(importNode, context, importParent) {
+        let evaldImportNode;
+        const inlineCSS = importNode.options.inline;
+
+        try {
+            evaldImportNode = importNode.evalForImport(context);
+        } catch (e) {
+            if (!e.filename) { e.index = importNode.getIndex(); e.filename = importNode.fileInfo().filename; }
+            // attempt to eval properly and treat as css
+            importNode.css = true;
+            // if that fails, this error will be thrown
+            importNode.error = e;
+        }
+
+        if (evaldImportNode && (!evaldImportNode.css || inlineCSS)) {
+            if (evaldImportNode.options.multiple) {
+                context.importMultiple = true;
+            }
+
+            // try appending if we haven't determined if it is css or not
+            const tryAppendLessExtension = evaldImportNode.css === undefined;
+
+            for (let i = 0; i < importParent.rules.length; i++) {
+                if (importParent.rules[i] === importNode) {
+                    importParent.rules[i] = evaldImportNode;
+                    break;
+                }
+            }
+
+            const onImported = this.onImported.bind(this, evaldImportNode, context);
+            const sequencedOnImported = this._sequencer.addImport(onImported);
+
+            this._importer.push(evaldImportNode.getPath(), tryAppendLessExtension, evaldImportNode.fileInfo(),
+                evaldImportNode.options, sequencedOnImported);
+        } else {
+            this.importCount--;
+            if (this.isFinished) {
+                this._sequencer.tryRun();
+            }
+        }
+    },
+    onImported: function (importNode, context, e, root, importedAtRoot, fullPath) {
+        if (e) {
+            if (!e.filename) {
+                e.index = importNode.getIndex(); e.filename = importNode.fileInfo().filename;
+            }
+            this.error = e;
+        }
+
+        const importVisitor = this;
+        const inlineCSS = importNode.options.inline;
+        const isPlugin = importNode.options.isPlugin;
+        const isOptional = importNode.options.optional;
+        const duplicateImport = importedAtRoot || fullPath in importVisitor.recursionDetector;
+
+        if (!context.importMultiple) {
+            if (duplicateImport) {
+                importNode.skip = true;
+            } else {
+                importNode.skip = () => {
+                    if (fullPath in importVisitor.onceFileDetectionMap) {
+                        return true;
+                    }
+                    importVisitor.onceFileDetectionMap[fullPath] = true;
+                    return false;
+                };
+            }
+        }
+
+        if (!fullPath && isOptional) {
+            importNode.skip = true;
+        }
+
+        if (root) {
+            importNode.root = root;
+            importNode.importedFilename = fullPath;
+
+            if (!inlineCSS && !isPlugin && (context.importMultiple || !duplicateImport)) {
+                importVisitor.recursionDetector[fullPath] = true;
+
+                const oldContext = this.context;
+                this.context = context;
+                try {
+                    this._visitor.visit(root);
+                } catch (e) {
+                    this.error = e;
+                }
+                this.context = oldContext;
+            }
+        }
+
+        importVisitor.importCount--;
+
+        if (importVisitor.isFinished) {
+            importVisitor._sequencer.tryRun();
+        }
+    },
+    visitDeclaration: function (declNode, visitArgs) {
+        if (declNode.value.type === 'DetachedRuleset') {
+            this.context.frames.unshift(declNode);
+        } else {
+            visitArgs.visitDeeper = false;
+        }
+    },
+    visitDeclarationOut: function(declNode) {
+        if (declNode.value.type === 'DetachedRuleset') {
+            this.context.frames.shift();
+        }
+    },
+    visitAtRule: function (atRuleNode, visitArgs) {
+        this.context.frames.unshift(atRuleNode);
+    },
+    visitAtRuleOut: function (atRuleNode) {
+        this.context.frames.shift();
+    },
+    visitMixinDefinition: function (mixinDefinitionNode, visitArgs) {
+        this.context.frames.unshift(mixinDefinitionNode);
+    },
+    visitMixinDefinitionOut: function (mixinDefinitionNode) {
+        this.context.frames.shift();
+    },
+    visitRuleset: function (rulesetNode, visitArgs) {
+        this.context.frames.unshift(rulesetNode);
+    },
+    visitRulesetOut: function (rulesetNode) {
+        this.context.frames.shift();
+    },
+    visitMedia: function (mediaNode, visitArgs) {
+        this.context.frames.unshift(mediaNode.rules[0]);
+    },
+    visitMediaOut: function (mediaNode) {
+        this.context.frames.shift();
+    }
+};
+export default ImportVisitor;

package/lib/less/visitors/index.js

@@ -0,0 +1,15 @@
+import Visitor from './visitor';
+import ImportVisitor from './import-visitor';
+import MarkVisibleSelectorsVisitor from './set-tree-visibility-visitor';
+import ExtendVisitor from './extend-visitor';
+import JoinSelectorVisitor from './join-selector-visitor';
+import ToCSSVisitor from './to-css-visitor';
+
+export default {
+    Visitor,
+    ImportVisitor,
+    MarkVisibleSelectorsVisitor,
+    ExtendVisitor,
+    JoinSelectorVisitor,
+    ToCSSVisitor
+};

package/lib/less/visitors/join-selector-visitor.js

@@ -0,0 +1,57 @@
+import Visitor from './visitor';
+
+class JoinSelectorVisitor {
+    constructor() {
+        this.contexts = [[]];
+        this._visitor = new Visitor(this);
+    }
+
+    run(root) {
+        return this._visitor.visit(root);
+    }
+
+    visitDeclaration(declNode, visitArgs) {
+        visitArgs.visitDeeper = false;
+    }
+
+    visitMixinDefinition(mixinDefinitionNode, visitArgs) {
+        visitArgs.visitDeeper = false;
+    }
+
+    visitRuleset(rulesetNode, visitArgs) {
+        const context = this.contexts[this.contexts.length - 1];
+        const paths = [];
+        let selectors;
+
+        this.contexts.push(paths);
+
+        if (!rulesetNode.root) {
+            selectors = rulesetNode.selectors;
+            if (selectors) {
+                selectors = selectors.filter(selector => selector.getIsOutput());
+                rulesetNode.selectors = selectors.length ? selectors : (selectors = null);
+                if (selectors) { rulesetNode.joinSelectors(paths, context, selectors); }
+            }
+            if (!selectors) { rulesetNode.rules = null; }
+            rulesetNode.paths = paths;
+        }
+    }
+
+    visitRulesetOut(rulesetNode) {
+        this.contexts.length = this.contexts.length - 1;
+    }
+
+    visitMedia(mediaNode, visitArgs) {
+        const context = this.contexts[this.contexts.length - 1];
+        mediaNode.rules[0].root = (context.length === 0 || context[0].multiMedia);
+    }
+
+    visitAtRule(atRuleNode, visitArgs) {
+        const context = this.contexts[this.contexts.length - 1];
+        if (atRuleNode.rules && atRuleNode.rules.length) {
+            atRuleNode.rules[0].root = (atRuleNode.isRooted || context.length === 0 || null);
+        }
+    }
+}
+
+export default JoinSelectorVisitor;

package/lib/less/visitors/set-tree-visibility-visitor.js

@@ -0,0 +1,45 @@
+class SetTreeVisibilityVisitor {
+    constructor(visible) {
+        this.visible = visible;
+    }
+
+    run(root) {
+        this.visit(root);
+    }
+
+    visitArray(nodes) {
+        if (!nodes) {
+            return nodes;
+        }
+
+        const cnt = nodes.length;
+        let i;
+        for (i = 0; i < cnt; i++) {
+            this.visit(nodes[i]);
+        }
+        return nodes;
+    }
+
+    visit(node) {
+        if (!node) {
+            return node;
+        }
+        if (node.constructor === Array) {
+            return this.visitArray(node);
+        }
+
+        if (!node.blocksVisibility || node.blocksVisibility()) {
+            return node;
+        }
+        if (this.visible) {
+            node.ensureVisibility();
+        } else {
+            node.ensureInvisibility();
+        }
+
+        node.accept(this);
+        return node;
+    }
+}
+
+export default SetTreeVisibilityVisitor;

package/lib/less/visitors/to-css-visitor.js

@@ -0,0 +1,363 @@
+import tree from '../tree';
+import Visitor from './visitor';
+
+class CSSVisitorUtils {
+    constructor(context) {
+        this._visitor = new Visitor(this);
+        this._context = context;
+    }
+
+    containsSilentNonBlockedChild(bodyRules) {
+        let rule;
+        if (!bodyRules) {
+            return false;
+        }
+        for (let r = 0; r < bodyRules.length; r++) {
+            rule = bodyRules[r];
+            if (rule.isSilent && rule.isSilent(this._context) && !rule.blocksVisibility()) {
+                // the atrule contains something that was referenced (likely by extend)
+                // therefore it needs to be shown in output too
+                return true;
+            }
+        }
+        return false;
+    }
+
+    keepOnlyVisibleChilds(owner) {
+        if (owner && owner.rules) {
+            owner.rules = owner.rules.filter(thing => thing.isVisible());
+        }
+    }
+
+    isEmpty(owner) {
+        return (owner && owner.rules) 
+            ? (owner.rules.length === 0) : true;
+    }
+
+    hasVisibleSelector(rulesetNode) {
+        return (rulesetNode && rulesetNode.paths)
+            ? (rulesetNode.paths.length > 0) : false;
+    }
+
+    resolveVisibility(node, originalRules) {
+        if (!node.blocksVisibility()) {
+            if (this.isEmpty(node) && !this.containsSilentNonBlockedChild(originalRules)) {
+                return ;
+            }
+
+            return node;
+        }
+
+        const compiledRulesBody = node.rules[0];
+        this.keepOnlyVisibleChilds(compiledRulesBody);
+
+        if (this.isEmpty(compiledRulesBody)) {
+            return ;
+        }
+
+        node.ensureVisibility();
+        node.removeVisibilityBlock();
+
+        return node;
+    }
+
+    isVisibleRuleset(rulesetNode) {
+        if (rulesetNode.firstRoot) {
+            return true;
+        }
+
+        if (this.isEmpty(rulesetNode)) {
+            return false;
+        }
+
+        if (!rulesetNode.root && !this.hasVisibleSelector(rulesetNode)) {
+            return false;
+        }
+
+        return true;
+    }
+}
+
+const ToCSSVisitor = function(context) {
+    this._visitor = new Visitor(this);
+    this._context = context;
+    this.utils = new CSSVisitorUtils(context);
+};
+
+ToCSSVisitor.prototype = {
+    isReplacing: true,
+    run: function (root) {
+        return this._visitor.visit(root);
+    },
+
+    visitDeclaration: function (declNode, visitArgs) {
+        if (declNode.blocksVisibility() || declNode.variable) {
+            return;
+        }
+        return declNode;
+    },
+
+    visitMixinDefinition: function (mixinNode, visitArgs) {
+        // mixin definitions do not get eval'd - this means they keep state
+        // so we have to clear that state here so it isn't used if toCSS is called twice
+        mixinNode.frames = [];
+    },
+
+    visitExtend: function (extendNode, visitArgs) {
+    },
+
+    visitComment: function (commentNode, visitArgs) {
+        if (commentNode.blocksVisibility() || commentNode.isSilent(this._context)) {
+            return;
+        }
+        return commentNode;
+    },
+
+    visitMedia: function(mediaNode, visitArgs) {
+        const originalRules = mediaNode.rules[0].rules;
+        mediaNode.accept(this._visitor);
+        visitArgs.visitDeeper = false;
+
+        return this.utils.resolveVisibility(mediaNode, originalRules);
+    },
+
+    visitImport: function (importNode, visitArgs) {
+        if (importNode.blocksVisibility()) {
+            return ;
+        }
+        return importNode;
+    },
+
+    visitAtRule: function(atRuleNode, visitArgs) {
+        if (atRuleNode.rules && atRuleNode.rules.length) {
+            return this.visitAtRuleWithBody(atRuleNode, visitArgs);
+        } else {
+            return this.visitAtRuleWithoutBody(atRuleNode, visitArgs);
+        }
+    },
+
+    visitAnonymous: function(anonymousNode, visitArgs) {
+        if (!anonymousNode.blocksVisibility()) {
+            anonymousNode.accept(this._visitor);
+            return anonymousNode;
+        }
+    },
+
+    visitAtRuleWithBody: function(atRuleNode, visitArgs) {
+        // if there is only one nested ruleset and that one has no path, then it is
+        // just fake ruleset
+        function hasFakeRuleset(atRuleNode) {
+            const bodyRules = atRuleNode.rules;
+            return bodyRules.length === 1 && (!bodyRules[0].paths || bodyRules[0].paths.length === 0);
+        }
+        function getBodyRules(atRuleNode) {
+            const nodeRules = atRuleNode.rules;
+            if (hasFakeRuleset(atRuleNode)) {
+                return nodeRules[0].rules;
+            }
+
+            return nodeRules;
+        }
+        // it is still true that it is only one ruleset in array
+        // this is last such moment
+        // process childs
+        const originalRules = getBodyRules(atRuleNode);
+        atRuleNode.accept(this._visitor);
+        visitArgs.visitDeeper = false;
+
+        if (!this.utils.isEmpty(atRuleNode)) {
+            this._mergeRules(atRuleNode.rules[0].rules);
+        }
+
+        return this.utils.resolveVisibility(atRuleNode, originalRules);
+    },
+
+    visitAtRuleWithoutBody: function(atRuleNode, visitArgs) {
+        if (atRuleNode.blocksVisibility()) {
+            return;
+        }
+
+        if (atRuleNode.name === '@charset') {
+            // Only output the debug info together with subsequent @charset definitions
+            // a comment (or @media statement) before the actual @charset atrule would
+            // be considered illegal css as it has to be on the first line
+            if (this.charset) {
+                if (atRuleNode.debugInfo) {
+                    const comment = new tree.Comment(`/* ${atRuleNode.toCSS(this._context).replace(/\n/g, '')} */\n`);
+                    comment.debugInfo = atRuleNode.debugInfo;
+                    return this._visitor.visit(comment);
+                }
+                return;
+            }
+            this.charset = true;
+        }
+
+        return atRuleNode;
+    },
+
+    checkValidNodes: function(rules, isRoot) {
+        if (!rules) {
+            return;
+        }
+
+        for (let i = 0; i < rules.length; i++) {
+            const ruleNode = rules[i];
+            if (isRoot && ruleNode instanceof tree.Declaration && !ruleNode.variable) {
+                throw { message: 'Properties must be inside selector blocks. They cannot be in the root',
+                    index: ruleNode.getIndex(), filename: ruleNode.fileInfo() && ruleNode.fileInfo().filename};
+            }
+            if (ruleNode instanceof tree.Call) {
+                throw { message: `Function '${ruleNode.name}' is undefined`,
+                    index: ruleNode.getIndex(), filename: ruleNode.fileInfo() && ruleNode.fileInfo().filename};
+            }
+            if (ruleNode.type && !ruleNode.allowRoot) {
+                throw { message: `${ruleNode.type} node returned by a function is not valid here`,
+                    index: ruleNode.getIndex(), filename: ruleNode.fileInfo() && ruleNode.fileInfo().filename};
+            }
+        }
+    },
+
+    visitRuleset: function (rulesetNode, visitArgs) {
+        // at this point rulesets are nested into each other
+        let rule;
+
+        const rulesets = [];
+
+        this.checkValidNodes(rulesetNode.rules, rulesetNode.firstRoot);
+
+        if (!rulesetNode.root) {
+            // remove invisible paths
+            this._compileRulesetPaths(rulesetNode);
+
+            // remove rulesets from this ruleset body and compile them separately
+            const nodeRules = rulesetNode.rules;
+
+            let nodeRuleCnt = nodeRules ? nodeRules.length : 0;
+            for (let i = 0; i < nodeRuleCnt; ) {
+                rule = nodeRules[i];
+                if (rule && rule.rules) {
+                    // visit because we are moving them out from being a child
+                    rulesets.push(this._visitor.visit(rule));
+                    nodeRules.splice(i, 1);
+                    nodeRuleCnt--;
+                    continue;
+                }
+                i++;
+            }
+            // accept the visitor to remove rules and refactor itself
+            // then we can decide nogw whether we want it or not
+            // compile body
+            if (nodeRuleCnt > 0) {
+                rulesetNode.accept(this._visitor);
+            } else {
+                rulesetNode.rules = null;
+            }
+            visitArgs.visitDeeper = false;
+        } else { // if (! rulesetNode.root) {
+            rulesetNode.accept(this._visitor);
+            visitArgs.visitDeeper = false;
+        }
+
+        if (rulesetNode.rules) {
+            this._mergeRules(rulesetNode.rules);
+            this._removeDuplicateRules(rulesetNode.rules);
+        }
+
+        // now decide whether we keep the ruleset
+        if (this.utils.isVisibleRuleset(rulesetNode)) {
+            rulesetNode.ensureVisibility();
+            rulesets.splice(0, 0, rulesetNode);
+        }
+
+        if (rulesets.length === 1) {
+            return rulesets[0];
+        }
+        return rulesets;
+    },
+
+    _compileRulesetPaths: function(rulesetNode) {
+        if (rulesetNode.paths) {
+            rulesetNode.paths = rulesetNode.paths
+                .filter(p => {
+                    let i;
+                    if (p[0].elements[0].combinator.value === ' ') {
+                        p[0].elements[0].combinator = new(tree.Combinator)('');
+                    }
+                    for (i = 0; i < p.length; i++) {
+                        if (p[i].isVisible() && p[i].getIsOutput()) {
+                            return true;
+                        }
+                    }
+                    return false;
+                });
+        }
+    },
+
+    _removeDuplicateRules: function(rules) {
+        if (!rules) { return; }
+
+        // remove duplicates
+        const ruleCache = {};
+
+        let ruleList;
+        let rule;
+        let i;
+
+        for (i = rules.length - 1; i >= 0 ; i--) {
+            rule = rules[i];
+            if (rule instanceof tree.Declaration) {
+                if (!ruleCache[rule.name]) {
+                    ruleCache[rule.name] = rule;
+                } else {
+                    ruleList = ruleCache[rule.name];
+                    if (ruleList instanceof tree.Declaration) {
+                        ruleList = ruleCache[rule.name] = [ruleCache[rule.name].toCSS(this._context)];
+                    }
+                    const ruleCSS = rule.toCSS(this._context);
+                    if (ruleList.indexOf(ruleCSS) !== -1) {
+                        rules.splice(i, 1);
+                    } else {
+                        ruleList.push(ruleCSS);
+                    }
+                }
+            }
+        }
+    },
+
+    _mergeRules: function(rules) {
+        if (!rules) {
+            return; 
+        }
+
+        const groups    = {};
+        const groupsArr = [];
+
+        for (let i = 0; i < rules.length; i++) {
+            const rule = rules[i];
+            if (rule.merge) {
+                const key = rule.name;
+                groups[key] ? rules.splice(i--, 1) : 
+                    groupsArr.push(groups[key] = []);
+                groups[key].push(rule);
+            }
+        }
+
+        groupsArr.forEach(group => {
+            if (group.length > 0) {
+                const result = group[0];
+                let space  = [];
+                const comma  = [new tree.Expression(space)];
+                group.forEach(rule => {
+                    if ((rule.merge === '+') && (space.length > 0)) {
+                        comma.push(new tree.Expression(space = []));
+                    }
+                    space.push(rule.value);
+                    result.important = result.important || rule.important;
+                });
+                result.value = new tree.Value(comma);
+            }
+        });
+    }
+};
+
+export default ToCSSVisitor;