less 4.8.1 → 5.0.0-alpha.1

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

@@ -1,203 +0,0 @@
-/* eslint-disable no-unused-vars */
-/**
- * @todo - Remove unused when JSDoc types are added for visitor methods
- */
-import contexts from '../contexts.js';
-import Visitor from './visitor.js';
-import ImportSequencer from './import-sequencer.js';
-import * as utils from '../utils.js';
-
-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), 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,
-            inlineCSS = importNode.options.inline,
-            isPlugin = importNode.options.isPlugin,
-            isOptional = importNode.options.optional,
-            duplicateImport = importedAtRoot || fullPath in importVisitor.recursionDetector;
-
-        if (!context.importMultiple) {
-            if (duplicateImport) {
-                importNode.skip = true;
-            } else {
-                importNode.skip = function() {
-                    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) {
-        if (atRuleNode.value) {
-            this.context.frames.unshift(atRuleNode);
-        } else if (atRuleNode.declarations && atRuleNode.declarations.length) {
-            if (atRuleNode.isRooted) {
-                this.context.frames.unshift(atRuleNode);
-            } else {
-                this.context.frames.unshift(atRuleNode.declarations[0]);
-            }
-        } else if (atRuleNode.rules && atRuleNode.rules.length) {
-            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

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

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

@@ -1,65 +0,0 @@
-/* eslint-disable no-unused-vars */
-/**
- * @todo - Remove unused when JSDoc types are added for visitor methods
- */
-import Visitor from './visitor.js';
-
-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(function(selector) { return 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.declarations && atRuleNode.declarations.length) {
-            atRuleNode.declarations[0].root = (context.length === 0 || context[0].multiMedia);
-        }
-        else 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

@@ -1,57 +0,0 @@
-import Node from '../tree/node.js';
-
-class SetTreeVisibilityVisitor {
-    /** @param {boolean} visible */
-    constructor(visible) {
-        this.visible = visible;
-    }
-
-    /** @param {Node} root */
-    run(root) {
-        this.visit(root);
-    }
-
-    /**
-     * @param {Node[]} nodes
-     * @returns {Node[]}
-     */
-    visitArray(nodes) {
-        if (!nodes) {
-            return nodes;
-        }
-
-        const cnt = nodes.length;
-        let i;
-        for (i = 0; i < cnt; i++) {
-            this.visit(nodes[i]);
-        }
-        return nodes;
-    }
-
-    /**
-     * @param {*} node
-     * @returns {*}
-     */
-    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

@@ -1,332 +0,0 @@
-/* eslint-disable no-unused-vars */
-/**
- * @todo - Remove unused when JSDoc types are added for visitor methods
- */
-import tree from '../tree/index.js';
-import Visitor from './visitor.js';
-import mergeRules from '../tree/merge-rules.js';
-
-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) {
-        if (!node.blocksVisibility()) {
-            if (this.isEmpty(node)) {
-                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}' did not return a root node`,
-                    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 = {};
-
-        for (let i = rules.length - 1; i >= 0 ; i--) {
-            let rule = rules[i];
-            if (rule instanceof tree.Declaration) {
-                if (!Object.prototype.hasOwnProperty.call(ruleCache, rule.name)) {
-                    ruleCache[rule.name] = rule;
-                } else {
-                    let ruleList = ruleCache[rule.name];
-                    if (!Array.isArray(ruleList)) {
-                        const prevRuleCSS = ruleList.toCSS(this._context);
-                        ruleList = ruleCache[rule.name] = [prevRuleCSS];
-                    }
-                    const ruleCSS = rule.toCSS(this._context);
-                    if (ruleList.indexOf(ruleCSS) !== -1) {
-                        rules.splice(i, 1);
-                    } else {
-                        ruleList.push(ruleCSS);
-                    }
-                }
-            }
-        }
-    },
-
-    _mergeRules: mergeRules
-};
-
-export default ToCSSVisitor;