less 3.10.0-beta.2 → 3.10.3

package/lib/less/tree/import.js

@@ -0,0 +1,184 @@
+import Node from './node';
+import Media from './media';
+import URL from './url';
+import Quoted from './quoted';
+import Ruleset from './ruleset';
+import Anonymous from './anonymous';
+import * as utils from '../utils';
+import LessError from '../less-error';
+
+//
+// CSS @import node
+//
+// The general strategy here is that we don't want to wait
+// for the parsing to be completed, before we start importing
+// the file. That's because in the context of a browser,
+// most of the time will be spent waiting for the server to respond.
+//
+// On creation, we push the import path to our import queue, though
+// `import,push`, we also pass it a callback, which it'll call once
+// the file has been fetched, and parsed.
+//
+class Import extends Node {
+    constructor(path, features, options, index, currentFileInfo, visibilityInfo) {
+        super();
+
+        this.options = options;
+        this._index = index;
+        this._fileInfo = currentFileInfo;
+        this.path = path;
+        this.features = features;
+        this.allowRoot = true;
+
+        if (this.options.less !== undefined || this.options.inline) {
+            this.css = !this.options.less || this.options.inline;
+        } else {
+            const pathValue = this.getPath();
+            if (pathValue && /[#\.\&\?]css([\?;].*)?$/.test(pathValue)) {
+                this.css = true;
+            }
+        }
+        this.copyVisibilityInfo(visibilityInfo);
+        this.setParent(this.features, this);
+        this.setParent(this.path, this);
+    }
+
+    accept(visitor) {
+        if (this.features) {
+            this.features = visitor.visit(this.features);
+        }
+        this.path = visitor.visit(this.path);
+        if (!this.options.isPlugin && !this.options.inline && this.root) {
+            this.root = visitor.visit(this.root);
+        }
+    }
+
+    genCSS(context, output) {
+        if (this.css && this.path._fileInfo.reference === undefined) {
+            output.add('@import ', this._fileInfo, this._index);
+            this.path.genCSS(context, output);
+            if (this.features) {
+                output.add(' ');
+                this.features.genCSS(context, output);
+            }
+            output.add(';');
+        }
+    }
+
+    getPath() {
+        return (this.path instanceof URL) ?
+            this.path.value.value : this.path.value;
+    }
+
+    isVariableImport() {
+        let path = this.path;
+        if (path instanceof URL) {
+            path = path.value;
+        }
+        if (path instanceof Quoted) {
+            return path.containsVariables();
+        }
+
+        return true;
+    }
+
+    evalForImport(context) {
+        let path = this.path;
+
+        if (path instanceof URL) {
+            path = path.value;
+        }
+
+        return new Import(path.eval(context), this.features, this.options, this._index, this._fileInfo, this.visibilityInfo());
+    }
+
+    evalPath(context) {
+        const path = this.path.eval(context);
+        const fileInfo = this._fileInfo;
+
+        if (!(path instanceof URL)) {
+            // Add the rootpath if the URL requires a rewrite
+            const pathValue = path.value;
+            if (fileInfo &&
+                pathValue &&
+                context.pathRequiresRewrite(pathValue)) {
+                path.value = context.rewritePath(pathValue, fileInfo.rootpath);
+            } else {
+                path.value = context.normalizePath(path.value);
+            }
+        }
+
+        return path;
+    }
+
+    eval(context) {
+        const result = this.doEval(context);
+        if (this.options.reference || this.blocksVisibility()) {
+            if (result.length || result.length === 0) {
+                result.forEach(node => {
+                    node.addVisibilityBlock();
+                }
+                );
+            } else {
+                result.addVisibilityBlock();
+            }
+        }
+        return result;
+    }
+
+    doEval(context) {
+        let ruleset;
+        let registry;
+        const features = this.features && this.features.eval(context);
+
+        if (this.options.isPlugin) {
+            if (this.root && this.root.eval) {
+                try {
+                    this.root.eval(context);
+                }
+                catch (e) {
+                    e.message = 'Plugin error during evaluation';
+                    throw new LessError(e, this.root.imports, this.root.filename);
+                }
+            }
+            registry = context.frames[0] && context.frames[0].functionRegistry;
+            if ( registry && this.root && this.root.functions ) {
+                registry.addMultiple( this.root.functions );
+            }
+
+            return [];
+        }
+
+        if (this.skip) {
+            if (typeof this.skip === 'function') {
+                this.skip = this.skip();
+            }
+            if (this.skip) {
+                return [];
+            }
+        }
+        if (this.options.inline) {
+            const contents = new Anonymous(this.root, 0,
+                {
+                    filename: this.importedFilename,
+                    reference: this.path._fileInfo && this.path._fileInfo.reference
+                }, true, true);
+
+            return this.features ? new Media([contents], this.features.value) : [contents];
+        } else if (this.css) {
+            const newImport = new Import(this.evalPath(context), features, this.options, this._index);
+            if (!newImport.css && this.error) {
+                throw this.error;
+            }
+            return newImport;
+        } else {
+            ruleset = new Ruleset(null, utils.copyArray(this.root.rules));
+            ruleset.evalImports(context);
+
+            return this.features ? new Media(ruleset.rules, this.features.value) : ruleset.rules;
+        }
+    }
+}
+
+Import.prototype.type = 'Import';
+export default Import;

package/lib/less/tree/index.js

@@ -0,0 +1,54 @@
+const tree = Object.create(null);
+
+import Node from './node';
+import Color from './color';
+import AtRule from './atrule';
+import DetachedRuleset from './detached-ruleset';
+import Operation from './operation';
+import Dimension from './dimension';
+import Unit from './unit';
+import Keyword from './keyword';
+import Variable from './variable';
+import Property from './property';
+import Ruleset from './ruleset';
+import Element from './element';
+import Attribute from './attribute';
+import Combinator from './combinator';
+import Selector from './selector';
+import Quoted from './quoted';
+import Expression from './expression';
+import Declaration from './declaration';
+import Call from './call';
+import URL from './url';
+import Import from './import';
+import Comment from './comment';
+import Anonymous from './anonymous';
+import Value from './value';
+import JavaScript from './javascript';
+import Assignment from './assignment';
+import Condition from './condition';
+import Paren from './paren';
+import Media from './media';
+import UnicodeDescriptor from './unicode-descriptor';
+import Negative from './negative';
+import Extend from './extend';
+import VariableCall from './variable-call';
+import NamespaceValue from './namespace-value';
+
+// mixins
+import MixinCall from './mixin-call';
+import MixinDefinition from './mixin-definition';
+
+export default {
+    Node, Color, AtRule, DetachedRuleset, Operation,
+    Dimension, Unit, Keyword, Variable, Property,
+    Ruleset, Element, Attribute, Combinator, Selector,
+    Quoted, Expression, Declaration, Call, URL, Import,
+    Comment, Anonymous, Value, JavaScript, Assignment,
+    Condition, Paren, Media, UnicodeDescriptor, Negative,
+    Extend, VariableCall, NamespaceValue,
+    mixin: {
+        Call: MixinCall,
+        Definition: MixinDefinition
+    }
+};

package/lib/less/tree/javascript.js

@@ -0,0 +1,33 @@
+import JsEvalNode from './js-eval-node';
+import Dimension from './dimension';
+import Quoted from './quoted';
+import Anonymous from './anonymous';
+
+class JavaScript extends JsEvalNode {
+    constructor(string, escaped, index, currentFileInfo) {
+        super();
+
+        this.escaped = escaped;
+        this.expression = string;
+        this._index = index;
+        this._fileInfo = currentFileInfo;
+    }
+
+    eval(context) {
+        const result = this.evaluateJavaScript(this.expression, context);
+        const type = typeof result;
+
+        if (type === 'number' && !isNaN(result)) {
+            return new Dimension(result);
+        } else if (type === 'string') {
+            return new Quoted(`"${result}"`, result, this.escaped, this._index);
+        } else if (Array.isArray(result)) {
+            return new Anonymous(result.join(', '));
+        } else {
+            return new Anonymous(result);
+        }
+    }
+}
+
+JavaScript.prototype.type = 'JavaScript';
+export default JavaScript;

package/lib/less/tree/js-eval-node.js

@@ -0,0 +1,58 @@
+import Node from './node';
+import Variable from './variable';
+
+class JsEvalNode extends Node {
+    evaluateJavaScript(expression, context) {
+        let result;
+        const that = this;
+        const evalContext = {};
+
+        if (!context.javascriptEnabled) {
+            throw { message: 'Inline JavaScript is not enabled. Is it set in your options?',
+                filename: this.fileInfo().filename,
+                index: this.getIndex() };
+        }
+
+        expression = expression.replace(/@\{([\w-]+)\}/g, (_, name) => that.jsify(new Variable(`@${name}`, that.getIndex(), that.fileInfo()).eval(context)));
+
+        try {
+            expression = new Function(`return (${expression})`);
+        } catch (e) {
+            throw { message: `JavaScript evaluation error: ${e.message} from \`${expression}\`` ,
+                filename: this.fileInfo().filename,
+                index: this.getIndex() };
+        }
+
+        const variables = context.frames[0].variables();
+        for (const k in variables) {
+            if (variables.hasOwnProperty(k)) {
+                /* jshint loopfunc:true */
+                evalContext[k.slice(1)] = {
+                    value: variables[k].value,
+                    toJS: function () {
+                        return this.value.eval(context).toCSS();
+                    }
+                };
+            }
+        }
+
+        try {
+            result = expression.call(evalContext);
+        } catch (e) {
+            throw { message: `JavaScript evaluation error: '${e.name}: ${e.message.replace(/["]/g, '\'')}'` ,
+                filename: this.fileInfo().filename,
+                index: this.getIndex() };
+        }
+        return result;
+    }
+
+    jsify(obj) {
+        if (Array.isArray(obj.value) && (obj.value.length > 1)) {
+            return `[${obj.value.map(v => v.toCSS()).join(', ')}]`;
+        } else {
+            return obj.toCSS();
+        }
+    }
+}
+
+export default JsEvalNode;

package/lib/less/tree/keyword.js

@@ -0,0 +1,21 @@
+import Node from './node';
+
+class Keyword extends Node {
+    constructor(value) {
+        super();
+
+        this.value = value;
+    }
+
+    genCSS(context, output) {
+        if (this.value === '%') { throw { type: 'Syntax', message: 'Invalid % without number' }; }
+        output.add(this.value);
+    }
+}
+
+Keyword.prototype.type = 'Keyword';
+
+Keyword.True = new Keyword('true');
+Keyword.False = new Keyword('false');
+
+export default Keyword;

package/lib/less/tree/media.js

@@ -0,0 +1,154 @@
+import Ruleset from './ruleset';
+import Value from './value';
+import Selector from './selector';
+import Anonymous from './anonymous';
+import Expression from './expression';
+import AtRule from './atrule';
+import * as utils from '../utils';
+
+class Media extends AtRule {
+    constructor(value, features, index, currentFileInfo, visibilityInfo) {
+        super();
+
+        this._index = index;
+        this._fileInfo = currentFileInfo;
+
+        const selectors = (new Selector([], null, null, this._index, this._fileInfo)).createEmptySelectors();
+
+        this.features = new Value(features);
+        this.rules = [new Ruleset(selectors, value)];
+        this.rules[0].allowImports = true;
+        this.copyVisibilityInfo(visibilityInfo);
+        this.allowRoot = true;
+        this.setParent(selectors, this);
+        this.setParent(this.features, this);
+        this.setParent(this.rules, this);
+    }
+
+    isRulesetLike() {
+        return true;
+    }
+
+    accept(visitor) {
+        if (this.features) {
+            this.features = visitor.visit(this.features);
+        }
+        if (this.rules) {
+            this.rules = visitor.visitArray(this.rules);
+        }
+    }
+
+    genCSS(context, output) {
+        output.add('@media ', this._fileInfo, this._index);
+        this.features.genCSS(context, output);
+        this.outputRuleset(context, output, this.rules);
+    }
+
+    eval(context) {
+        if (!context.mediaBlocks) {
+            context.mediaBlocks = [];
+            context.mediaPath = [];
+        }
+
+        const media = new Media(null, [], this._index, this._fileInfo, this.visibilityInfo());
+        if (this.debugInfo) {
+            this.rules[0].debugInfo = this.debugInfo;
+            media.debugInfo = this.debugInfo;
+        }
+        
+        media.features = this.features.eval(context);
+
+        context.mediaPath.push(media);
+        context.mediaBlocks.push(media);
+
+        this.rules[0].functionRegistry = context.frames[0].functionRegistry.inherit();
+        context.frames.unshift(this.rules[0]);
+        media.rules = [this.rules[0].eval(context)];
+        context.frames.shift();
+
+        context.mediaPath.pop();
+
+        return context.mediaPath.length === 0 ? media.evalTop(context) :
+            media.evalNested(context);
+    }
+
+    evalTop(context) {
+        let result = this;
+
+        // Render all dependent Media blocks.
+        if (context.mediaBlocks.length > 1) {
+            const selectors = (new Selector([], null, null, this.getIndex(), this.fileInfo())).createEmptySelectors();
+            result = new Ruleset(selectors, context.mediaBlocks);
+            result.multiMedia = true;
+            result.copyVisibilityInfo(this.visibilityInfo());
+            this.setParent(result, this);
+        }
+
+        delete context.mediaBlocks;
+        delete context.mediaPath;
+
+        return result;
+    }
+
+    evalNested(context) {
+        let i;
+        let value;
+        const path = context.mediaPath.concat([this]);
+
+        // Extract the media-query conditions separated with `,` (OR).
+        for (i = 0; i < path.length; i++) {
+            value = path[i].features instanceof Value ?
+                path[i].features.value : path[i].features;
+            path[i] = Array.isArray(value) ? value : [value];
+        }
+
+        // Trace all permutations to generate the resulting media-query.
+        //
+        // (a, b and c) with nested (d, e) ->
+        //    a and d
+        //    a and e
+        //    b and c and d
+        //    b and c and e
+        this.features = new Value(this.permute(path).map(path => {
+            path = path.map(fragment => fragment.toCSS ? fragment : new Anonymous(fragment));
+
+            for (i = path.length - 1; i > 0; i--) {
+                path.splice(i, 0, new Anonymous('and'));
+            }
+
+            return new Expression(path);
+        }));
+        this.setParent(this.features, this);
+
+        // Fake a tree-node that doesn't output anything.
+        return new Ruleset([], []);
+    }
+
+    permute(arr) {
+        if (arr.length === 0) {
+            return [];
+        } else if (arr.length === 1) {
+            return arr[0];
+        } else {
+            const result = [];
+            const rest = this.permute(arr.slice(1));
+            for (let i = 0; i < rest.length; i++) {
+                for (let j = 0; j < arr[0].length; j++) {
+                    result.push([arr[0][j]].concat(rest[i]));
+                }
+            }
+            return result;
+        }
+    }
+
+    bubbleSelectors(selectors) {
+        if (!selectors) {
+            return;
+        }
+        this.rules = [new Ruleset(utils.copyArray(selectors), [this.rules[0]])];
+        this.setParent(this.rules, this);
+    }
+}
+
+Media.prototype.type = 'Media';
+export default Media;