less 3.10.0-beta.2 → 3.10.3

package/lib/less/tree/mixin-call.js

@@ -0,0 +1,215 @@
+import Node from './node';
+import Selector from './selector';
+import MixinDefinition from './mixin-definition';
+import defaultFunc from '../functions/default';
+
+class MixinCall extends Node {
+    constructor(elements, args, index, currentFileInfo, important) {
+        super();
+
+        this.selector = new Selector(elements);
+        this.arguments = args || [];
+        this._index = index;
+        this._fileInfo = currentFileInfo;
+        this.important = important;
+        this.allowRoot = true;
+        this.setParent(this.selector, this);
+    }
+
+    accept(visitor) {
+        if (this.selector) {
+            this.selector = visitor.visit(this.selector);
+        }
+        if (this.arguments.length) {
+            this.arguments = visitor.visitArray(this.arguments);
+        }
+    }
+
+    eval(context) {
+        let mixins;
+        let mixin;
+        let mixinPath;
+        const args = [];
+        let arg;
+        let argValue;
+        const rules = [];
+        let match = false;
+        let i;
+        let m;
+        let f;
+        let isRecursive;
+        let isOneFound;
+        const candidates = [];
+        let candidate;
+        const conditionResult = [];
+        let defaultResult;
+        const defFalseEitherCase = -1;
+        const defNone = 0;
+        const defTrue = 1;
+        const defFalse = 2;
+        let count;
+        let originalRuleset;
+        let noArgumentsFilter;
+
+        this.selector = this.selector.eval(context);
+
+        function calcDefGroup(mixin, mixinPath) {
+            let f;
+            let p;
+            let namespace;
+
+            for (f = 0; f < 2; f++) {
+                conditionResult[f] = true;
+                defaultFunc.value(f);
+                for (p = 0; p < mixinPath.length && conditionResult[f]; p++) {
+                    namespace = mixinPath[p];
+                    if (namespace.matchCondition) {
+                        conditionResult[f] = conditionResult[f] && namespace.matchCondition(null, context);
+                    }
+                }
+                if (mixin.matchCondition) {
+                    conditionResult[f] = conditionResult[f] && mixin.matchCondition(args, context);
+                }
+            }
+            if (conditionResult[0] || conditionResult[1]) {
+                if (conditionResult[0] != conditionResult[1]) {
+                    return conditionResult[1] ?
+                        defTrue : defFalse;
+                }
+
+                return defNone;
+            }
+            return defFalseEitherCase;
+        }
+
+        for (i = 0; i < this.arguments.length; i++) {
+            arg = this.arguments[i];
+            argValue = arg.value.eval(context);
+            if (arg.expand && Array.isArray(argValue.value)) {
+                argValue = argValue.value;
+                for (m = 0; m < argValue.length; m++) {
+                    args.push({value: argValue[m]});
+                }
+            } else {
+                args.push({name: arg.name, value: argValue});
+            }
+        }
+
+        noArgumentsFilter = rule => rule.matchArgs(null, context);
+
+        for (i = 0; i < context.frames.length; i++) {
+            if ((mixins = context.frames[i].find(this.selector, null, noArgumentsFilter)).length > 0) {
+                isOneFound = true;
+
+                // To make `default()` function independent of definition order we have two "subpasses" here.
+                // At first we evaluate each guard *twice* (with `default() == true` and `default() == false`),
+                // and build candidate list with corresponding flags. Then, when we know all possible matches,
+                // we make a final decision.
+
+                for (m = 0; m < mixins.length; m++) {
+                    mixin = mixins[m].rule;
+                    mixinPath = mixins[m].path;
+                    isRecursive = false;
+                    for (f = 0; f < context.frames.length; f++) {
+                        if ((!(mixin instanceof MixinDefinition)) && mixin === (context.frames[f].originalRuleset || context.frames[f])) {
+                            isRecursive = true;
+                            break;
+                        }
+                    }
+                    if (isRecursive) {
+                        continue;
+                    }
+
+                    if (mixin.matchArgs(args, context)) {
+                        candidate = {mixin, group: calcDefGroup(mixin, mixinPath)};
+
+                        if (candidate.group !== defFalseEitherCase) {
+                            candidates.push(candidate);
+                        }
+
+                        match = true;
+                    }
+                }
+
+                defaultFunc.reset();
+
+                count = [0, 0, 0];
+                for (m = 0; m < candidates.length; m++) {
+                    count[candidates[m].group]++;
+                }
+
+                if (count[defNone] > 0) {
+                    defaultResult = defFalse;
+                } else {
+                    defaultResult = defTrue;
+                    if ((count[defTrue] + count[defFalse]) > 1) {
+                        throw { type: 'Runtime',
+                            message: `Ambiguous use of \`default()\` found when matching for \`${this.format(args)}\``,
+                            index: this.getIndex(), filename: this.fileInfo().filename };
+                    }
+                }
+
+                for (m = 0; m < candidates.length; m++) {
+                    candidate = candidates[m].group;
+                    if ((candidate === defNone) || (candidate === defaultResult)) {
+                        try {
+                            mixin = candidates[m].mixin;
+                            if (!(mixin instanceof MixinDefinition)) {
+                                originalRuleset = mixin.originalRuleset || mixin;
+                                mixin = new MixinDefinition('', [], mixin.rules, null, false, null, originalRuleset.visibilityInfo());
+                                mixin.originalRuleset = originalRuleset;
+                            }
+                            const newRules = mixin.evalCall(context, args, this.important).rules;
+                            this._setVisibilityToReplacement(newRules);
+                            Array.prototype.push.apply(rules, newRules);
+                        } catch (e) {
+                            throw { message: e.message, index: this.getIndex(), filename: this.fileInfo().filename, stack: e.stack };
+                        }
+                    }
+                }
+
+                if (match) {
+                    return rules;
+                }
+            }
+        }
+        if (isOneFound) {
+            throw { type:    'Runtime',
+                message: `No matching definition was found for \`${this.format(args)}\``,
+                index:   this.getIndex(), filename: this.fileInfo().filename };
+        } else {
+            throw { type:    'Name',
+                message: `${this.selector.toCSS().trim()} is undefined`,
+                index:   this.getIndex(), filename: this.fileInfo().filename };
+        }
+    }
+
+    _setVisibilityToReplacement(replacement) {
+        let i;
+        let rule;
+        if (this.blocksVisibility()) {
+            for (i = 0; i < replacement.length; i++) {
+                rule = replacement[i];
+                rule.addVisibilityBlock();
+            }
+        }
+    }
+
+    format(args) {
+        return `${this.selector.toCSS().trim()}(${args ? args.map(a => {
+            let argValue = '';
+            if (a.name) {
+                argValue += `${a.name}:`;
+            }
+            if (a.value.toCSS) {
+                argValue += a.value.toCSS();
+            } else {
+                argValue += '???';
+            }
+            return argValue;
+        }).join(', ') : ''})`;
+    }
+}
+
+MixinCall.prototype.type = 'MixinCall';
+export default MixinCall;

package/lib/less/tree/mixin-definition.js

@@ -0,0 +1,229 @@
+import Selector from './selector';
+import Element from './element';
+import Ruleset from './ruleset';
+import Declaration from './declaration';
+import DetachedRuleset from './detached-ruleset';
+import Expression from './expression';
+import contexts from '../contexts';
+import * as utils from '../utils';
+
+class Definition extends Ruleset {
+    constructor(name, params, rules, condition, variadic, frames, visibilityInfo) {
+        super();
+
+        this.name = name || 'anonymous mixin';
+        this.selectors = [new Selector([new Element(null, name, false, this._index, this._fileInfo)])];
+        this.params = params;
+        this.condition = condition;
+        this.variadic = variadic;
+        this.arity = params.length;
+        this.rules = rules;
+        this._lookups = {};
+        const optionalParameters = [];
+        this.required = params.reduce((count, p) => {
+            if (!p.name || (p.name && !p.value)) {
+                return count + 1;
+            }
+            else {
+                optionalParameters.push(p.name);
+                return count;
+            }
+        }, 0);
+        this.optionalParameters = optionalParameters;
+        this.frames = frames;
+        this.copyVisibilityInfo(visibilityInfo);
+        this.allowRoot = true;
+    }
+
+    accept(visitor) {
+        if (this.params && this.params.length) {
+            this.params = visitor.visitArray(this.params);
+        }
+        this.rules = visitor.visitArray(this.rules);
+        if (this.condition) {
+            this.condition = visitor.visit(this.condition);
+        }
+    }
+
+    evalParams(context, mixinEnv, args, evaldArguments) {
+        /* jshint boss:true */
+        const frame = new Ruleset(null, null);
+
+        let varargs;
+        let arg;
+        const params = utils.copyArray(this.params);
+        let i;
+        let j;
+        let val;
+        let name;
+        let isNamedFound;
+        let argIndex;
+        let argsLength = 0;
+
+        if (mixinEnv.frames && mixinEnv.frames[0] && mixinEnv.frames[0].functionRegistry) {
+            frame.functionRegistry = mixinEnv.frames[0].functionRegistry.inherit();
+        }
+        mixinEnv = new contexts.Eval(mixinEnv, [frame].concat(mixinEnv.frames));
+
+        if (args) {
+            args = utils.copyArray(args);
+            argsLength = args.length;
+
+            for (i = 0; i < argsLength; i++) {
+                arg = args[i];
+                if (name = (arg && arg.name)) {
+                    isNamedFound = false;
+                    for (j = 0; j < params.length; j++) {
+                        if (!evaldArguments[j] && name === params[j].name) {
+                            evaldArguments[j] = arg.value.eval(context);
+                            frame.prependRule(new Declaration(name, arg.value.eval(context)));
+                            isNamedFound = true;
+                            break;
+                        }
+                    }
+                    if (isNamedFound) {
+                        args.splice(i, 1);
+                        i--;
+                        continue;
+                    } else {
+                        throw { type: 'Runtime', message: `Named argument for ${this.name} ${args[i].name} not found` };
+                    }
+                }
+            }
+        }
+        argIndex = 0;
+        for (i = 0; i < params.length; i++) {
+            if (evaldArguments[i]) { continue; }
+
+            arg = args && args[argIndex];
+
+            if (name = params[i].name) {
+                if (params[i].variadic) {
+                    varargs = [];
+                    for (j = argIndex; j < argsLength; j++) {
+                        varargs.push(args[j].value.eval(context));
+                    }
+                    frame.prependRule(new Declaration(name, new Expression(varargs).eval(context)));
+                } else {
+                    val = arg && arg.value;
+                    if (val) {
+                        // This was a mixin call, pass in a detached ruleset of it's eval'd rules
+                        if (Array.isArray(val)) {
+                            val = new DetachedRuleset(new Ruleset('', val));
+                        }
+                        else {
+                            val = val.eval(context);
+                        }
+                    } else if (params[i].value) {
+                        val = params[i].value.eval(mixinEnv);
+                        frame.resetCache();
+                    } else {
+                        throw { type: 'Runtime', message: `wrong number of arguments for ${this.name} (${argsLength} for ${this.arity})` };
+                    }
+
+                    frame.prependRule(new Declaration(name, val));
+                    evaldArguments[i] = val;
+                }
+            }
+
+            if (params[i].variadic && args) {
+                for (j = argIndex; j < argsLength; j++) {
+                    evaldArguments[j] = args[j].value.eval(context);
+                }
+            }
+            argIndex++;
+        }
+
+        return frame;
+    }
+
+    makeImportant() {
+        const rules = !this.rules ? this.rules : this.rules.map(r => {
+            if (r.makeImportant) {
+                return r.makeImportant(true);
+            } else {
+                return r;
+            }
+        });
+        const result = new Definition(this.name, this.params, rules, this.condition, this.variadic, this.frames);
+        return result;
+    }
+
+    eval(context) {
+        return new Definition(this.name, this.params, this.rules, this.condition, this.variadic, this.frames || utils.copyArray(context.frames));
+    }
+
+    evalCall(context, args, important) {
+        const _arguments = [];
+        const mixinFrames = this.frames ? this.frames.concat(context.frames) : context.frames;
+        const frame = this.evalParams(context, new contexts.Eval(context, mixinFrames), args, _arguments);
+        let rules;
+        let ruleset;
+
+        frame.prependRule(new Declaration('@arguments', new Expression(_arguments).eval(context)));
+
+        rules = utils.copyArray(this.rules);
+
+        ruleset = new Ruleset(null, rules);
+        ruleset.originalRuleset = this;
+        ruleset = ruleset.eval(new contexts.Eval(context, [this, frame].concat(mixinFrames)));
+        if (important) {
+            ruleset = ruleset.makeImportant();
+        }
+        return ruleset;
+    }
+
+    matchCondition(args, context) {
+        if (this.condition && !this.condition.eval(
+            new contexts.Eval(context,
+                [this.evalParams(context, /* the parameter variables */
+                    new contexts.Eval(context, this.frames ? this.frames.concat(context.frames) : context.frames), args, [])]
+                    .concat(this.frames || []) // the parent namespace/mixin frames
+                    .concat(context.frames)))) { // the current environment frames
+            return false;
+        }
+        return true;
+    }
+
+    matchArgs(args, context) {
+        const allArgsCnt = (args && args.length) || 0;
+        let len;
+        const optionalParameters = this.optionalParameters;
+        const requiredArgsCnt = !args ? 0 : args.reduce((count, p) => {
+            if (optionalParameters.indexOf(p.name) < 0) {
+                return count + 1;
+            } else {
+                return count;
+            }
+        }, 0);
+
+        if (!this.variadic) {
+            if (requiredArgsCnt < this.required) {
+                return false;
+            }
+            if (allArgsCnt > this.params.length) {
+                return false;
+            }
+        } else {
+            if (requiredArgsCnt < (this.required - 1)) {
+                return false;
+            }
+        }
+
+        // check patterns
+        len = Math.min(requiredArgsCnt, this.arity);
+
+        for (let i = 0; i < len; i++) {
+            if (!this.params[i].name && !this.params[i].variadic) {
+                if (args[i].value.eval(context).toCSS() != this.params[i].value.eval(context).toCSS()) {
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+}
+
+Definition.prototype.type = 'MixinDefinition';
+Definition.prototype.evalFirst = true;
+export default Definition;

package/lib/less/tree/namespace-value.js

@@ -0,0 +1,87 @@
+import Node from './node';
+import Variable from './variable';
+import Ruleset from './ruleset';
+import Selector from './selector';
+
+class NamespaceValue extends Node {
+    constructor(ruleCall, lookups, important, index, fileInfo) {
+        super();
+
+        this.value = ruleCall;
+        this.lookups = lookups;
+        this.important = important;
+        this._index = index;
+        this._fileInfo = fileInfo;
+    }
+
+    eval(context) {
+        let i;
+        let j;
+        let name;
+        let rules = this.value.eval(context);
+
+        for (i = 0; i < this.lookups.length; i++) {
+            name = this.lookups[i];
+
+            /**
+             * Eval'd DRs return rulesets.
+             * Eval'd mixins return rules, so let's make a ruleset if we need it.
+             * We need to do this because of late parsing of values
+             */
+            if (Array.isArray(rules)) {
+                rules = new Ruleset([new Selector()], rules);
+            }
+
+            if (name === '') {
+                rules = rules.lastDeclaration();
+            }
+            else if (name.charAt(0) === '@') {
+                if (name.charAt(1) === '@') {
+                    name = `@${new Variable(name.substr(1)).eval(context).value}`;
+                }
+                if (rules.variables) {
+                    rules = rules.variable(name);
+                }
+                
+                if (!rules) {
+                    throw { type: 'Name',
+                        message: `variable ${name} not found`,
+                        filename: this.fileInfo().filename,
+                        index: this.getIndex() };
+                }
+            }
+            else {
+                if (name.substring(0, 2) === '$@') {
+                    name = `$${new Variable(name.substr(1)).eval(context).value}`;
+                }
+                else {
+                    name = name.charAt(0) === '$' ? name : `$${name}`;
+                }
+                if (rules.properties) {
+                    rules = rules.property(name);
+                }
+            
+                if (!rules) {
+                    throw { type: 'Name',
+                        message: `property "${name.substr(1)}" not found`,
+                        filename: this.fileInfo().filename,
+                        index: this.getIndex() };
+                }
+                // Properties are an array of values, since a ruleset can have multiple props.
+                // We pick the last one (the "cascaded" value)
+                rules = rules[rules.length - 1];
+            }
+
+            if (rules.value) {
+                rules = rules.eval(context).value;
+            }
+            if (rules.ruleset) {
+                rules = rules.ruleset.eval(context);
+            }
+        }
+        return rules;
+    }
+}
+
+NamespaceValue.prototype.type = 'NamespaceValue';
+export default NamespaceValue;

package/lib/less/tree/negative.js

@@ -0,0 +1,26 @@
+import Node from './node';
+import Operation from './operation';
+import Dimension from './dimension';
+
+class Negative extends Node {
+    constructor(node) {
+        super();
+
+        this.value = node;
+    }
+
+    genCSS(context, output) {
+        output.add('-');
+        this.value.genCSS(context, output);
+    }
+
+    eval(context) {
+        if (context.isMathOn()) {
+            return (new Operation('*', [new Dimension(-1), this.value])).eval(context);
+        }
+        return new Negative(this.value.eval(context));
+    }
+}
+
+Negative.prototype.type = 'Negative';
+export default Negative;