less 3.10.0-beta.2 → 3.10.3

package/lib/less/plugin-manager.js

@@ -0,0 +1,168 @@
+/**
+ * Plugin Manager
+ */
+class PluginManager {
+    constructor(less) {
+        this.less = less;
+        this.visitors = [];
+        this.preProcessors = [];
+        this.postProcessors = [];
+        this.installedPlugins = [];
+        this.fileManagers = [];
+        this.iterator = -1;
+        this.pluginCache = {};
+        this.Loader = new less.PluginLoader(less);
+    }
+
+    /**
+     * Adds all the plugins in the array
+     * @param {Array} plugins
+     */
+    addPlugins(plugins) {
+        if (plugins) {
+            for (let i = 0; i < plugins.length; i++) {
+                this.addPlugin(plugins[i]);
+            }
+        }
+    }
+
+    /**
+     *
+     * @param plugin
+     * @param {String} filename
+     */
+    addPlugin(plugin, filename, functionRegistry) {
+        this.installedPlugins.push(plugin);
+        if (filename) {
+            this.pluginCache[filename] = plugin;
+        }
+        if (plugin.install) {
+            plugin.install(this.less, this, functionRegistry || this.less.functions.functionRegistry);
+        }
+    }
+
+    /**
+     *
+     * @param filename
+     */
+    get(filename) {
+        return this.pluginCache[filename];
+    }
+
+    /**
+     * Adds a visitor. The visitor object has options on itself to determine
+     * when it should run.
+     * @param visitor
+     */
+    addVisitor(visitor) {
+        this.visitors.push(visitor);
+    }
+
+    /**
+     * Adds a pre processor object
+     * @param {object} preProcessor
+     * @param {number} priority - guidelines 1 = before import, 1000 = import, 2000 = after import
+     */
+    addPreProcessor(preProcessor, priority) {
+        let indexToInsertAt;
+        for (indexToInsertAt = 0; indexToInsertAt < this.preProcessors.length; indexToInsertAt++) {
+            if (this.preProcessors[indexToInsertAt].priority >= priority) {
+                break;
+            }
+        }
+        this.preProcessors.splice(indexToInsertAt, 0, {preProcessor, priority});
+    }
+
+    /**
+     * Adds a post processor object
+     * @param {object} postProcessor
+     * @param {number} priority - guidelines 1 = before compression, 1000 = compression, 2000 = after compression
+     */
+    addPostProcessor(postProcessor, priority) {
+        let indexToInsertAt;
+        for (indexToInsertAt = 0; indexToInsertAt < this.postProcessors.length; indexToInsertAt++) {
+            if (this.postProcessors[indexToInsertAt].priority >= priority) {
+                break;
+            }
+        }
+        this.postProcessors.splice(indexToInsertAt, 0, {postProcessor, priority});
+    }
+
+    /**
+     *
+     * @param manager
+     */
+    addFileManager(manager) {
+        this.fileManagers.push(manager);
+    }
+
+    /**
+     *
+     * @returns {Array}
+     * @private
+     */
+    getPreProcessors() {
+        const preProcessors = [];
+        for (let i = 0; i < this.preProcessors.length; i++) {
+            preProcessors.push(this.preProcessors[i].preProcessor);
+        }
+        return preProcessors;
+    }
+
+    /**
+     *
+     * @returns {Array}
+     * @private
+     */
+    getPostProcessors() {
+        const postProcessors = [];
+        for (let i = 0; i < this.postProcessors.length; i++) {
+            postProcessors.push(this.postProcessors[i].postProcessor);
+        }
+        return postProcessors;
+    }
+
+    /**
+     *
+     * @returns {Array}
+     * @private
+     */
+    getVisitors() {
+        return this.visitors;
+    }
+
+    visitor() {
+        const self = this;
+        return {
+            first: function() {
+                self.iterator = -1;
+                return self.visitors[self.iterator];
+            },
+            get: function() {
+                self.iterator += 1;
+                return self.visitors[self.iterator];
+            }
+        };
+    }
+
+    /**
+     *
+     * @returns {Array}
+     * @private
+     */
+    getFileManagers() {
+        return this.fileManagers;
+    }
+}
+
+let pm;
+
+function PluginManagerFactory(less, newFactory) {
+    if (newFactory || !pm) {
+        pm = new PluginManager(less);
+    }
+    return pm;
+};
+
+//
+export default PluginManagerFactory;

package/lib/less/render.js

@@ -0,0 +1,42 @@
+let PromiseConstructor;
+import * as utils from './utils';
+
+export default (environment, ParseTree, ImportManager) => {
+    const render = function (input, options, callback) {
+        if (typeof options === 'function') {
+            callback = options;
+            options = utils.copyOptions(this.options, {});
+        }
+        else {
+            options = utils.copyOptions(this.options, options || {});
+        }
+
+        if (!callback) {
+            const self = this;
+            return new Promise((resolve, reject) => {
+                render.call(self, input, options, (err, output) => {
+                    if (err) {
+                        reject(err);
+                    } else {
+                        resolve(output);
+                    }
+                });
+            });
+        } else {
+            this.parse(input, options, (err, root, imports, options) => {
+                if (err) { return callback(err); }
+
+                let result;
+                try {
+                    const parseTree = new ParseTree(root, imports);
+                    result = parseTree.toCSS(options);
+                }
+                catch (err) { return callback(err); }
+
+                callback(null, result);
+            });
+        }
+    };
+
+    return render;
+};

package/lib/less/source-map-builder.js

@@ -0,0 +1,77 @@
+export default (SourceMapOutput, environment) => {
+    class SourceMapBuilder {
+        constructor(options) {
+            this.options = options;
+        }
+
+        toCSS(rootNode, options, imports) {
+            const sourceMapOutput = new SourceMapOutput(
+                {
+                    contentsIgnoredCharsMap: imports.contentsIgnoredChars,
+                    rootNode,
+                    contentsMap: imports.contents,
+                    sourceMapFilename: this.options.sourceMapFilename,
+                    sourceMapURL: this.options.sourceMapURL,
+                    outputFilename: this.options.sourceMapOutputFilename,
+                    sourceMapBasepath: this.options.sourceMapBasepath,
+                    sourceMapRootpath: this.options.sourceMapRootpath,
+                    outputSourceFiles: this.options.outputSourceFiles,
+                    sourceMapGenerator: this.options.sourceMapGenerator,
+                    sourceMapFileInline: this.options.sourceMapFileInline
+                });
+
+            const css = sourceMapOutput.toCSS(options);
+            this.sourceMap = sourceMapOutput.sourceMap;
+            this.sourceMapURL = sourceMapOutput.sourceMapURL;
+            if (this.options.sourceMapInputFilename) {
+                this.sourceMapInputFilename = sourceMapOutput.normalizeFilename(this.options.sourceMapInputFilename);
+            }
+            if (this.options.sourceMapBasepath !== undefined && this.sourceMapURL !== undefined) {
+                this.sourceMapURL = sourceMapOutput.removeBasepath(this.sourceMapURL);
+            }
+            return css + this.getCSSAppendage();
+        }
+
+        getCSSAppendage() {
+
+            let sourceMapURL = this.sourceMapURL;
+            if (this.options.sourceMapFileInline) {
+                if (this.sourceMap === undefined) {
+                    return '';
+                }
+                sourceMapURL = `data:application/json;base64,${environment.encodeBase64(this.sourceMap)}`;
+            }
+
+            if (sourceMapURL) {
+                return `/*# sourceMappingURL=${sourceMapURL} */`;
+            }
+            return '';
+        }
+
+        getExternalSourceMap() {
+            return this.sourceMap;
+        }
+
+        setExternalSourceMap(sourceMap) {
+            this.sourceMap = sourceMap;
+        }
+
+        isInline() {
+            return this.options.sourceMapFileInline;
+        }
+
+        getSourceMapURL() {
+            return this.sourceMapURL;
+        }
+
+        getOutputFilename() {
+            return this.options.sourceMapOutputFilename;
+        }
+
+        getInputFilename() {
+            return this.sourceMapInputFilename;
+        }
+    }
+
+    return SourceMapBuilder;
+};

package/lib/less/source-map-output.js

@@ -0,0 +1,149 @@
+export default environment => {
+    class SourceMapOutput {
+        constructor(options) {
+            this._css = [];
+            this._rootNode = options.rootNode;
+            this._contentsMap = options.contentsMap;
+            this._contentsIgnoredCharsMap = options.contentsIgnoredCharsMap;
+            if (options.sourceMapFilename) {
+                this._sourceMapFilename = options.sourceMapFilename.replace(/\\/g, '/');
+            }
+            this._outputFilename = options.outputFilename;
+            this.sourceMapURL = options.sourceMapURL;
+            if (options.sourceMapBasepath) {
+                this._sourceMapBasepath = options.sourceMapBasepath.replace(/\\/g, '/');
+            }
+            if (options.sourceMapRootpath) {
+                this._sourceMapRootpath = options.sourceMapRootpath.replace(/\\/g, '/');
+                if (this._sourceMapRootpath.charAt(this._sourceMapRootpath.length - 1) !== '/') {
+                    this._sourceMapRootpath += '/';
+                }
+            } else {
+                this._sourceMapRootpath = '';
+            }
+            this._outputSourceFiles = options.outputSourceFiles;
+            this._sourceMapGeneratorConstructor = environment.getSourceMapGenerator();
+
+            this._lineNumber = 0;
+            this._column = 0;
+        }
+
+        removeBasepath(path) {
+            if (this._sourceMapBasepath && path.indexOf(this._sourceMapBasepath) === 0) {
+                path = path.substring(this._sourceMapBasepath.length);
+                if (path.charAt(0) === '\\' || path.charAt(0) === '/') {
+                    path = path.substring(1);
+                }
+            }
+
+            return path;
+        }
+
+        normalizeFilename(filename) {
+            filename = filename.replace(/\\/g, '/');
+            filename = this.removeBasepath(filename);
+            return (this._sourceMapRootpath || '') + filename;
+        }
+
+        add(chunk, fileInfo, index, mapLines) {
+            // ignore adding empty strings
+            if (!chunk) {
+                return;
+            }
+
+            let lines;
+            let sourceLines;
+            let columns;
+            let sourceColumns;
+            let i;
+
+            if (fileInfo && fileInfo.filename) {
+                let inputSource = this._contentsMap[fileInfo.filename];
+
+                // remove vars/banner added to the top of the file
+                if (this._contentsIgnoredCharsMap[fileInfo.filename]) {
+                    // adjust the index
+                    index -= this._contentsIgnoredCharsMap[fileInfo.filename];
+                    if (index < 0) { index = 0; }
+                    // adjust the source
+                    inputSource = inputSource.slice(this._contentsIgnoredCharsMap[fileInfo.filename]);
+                }
+
+                // ignore empty content
+                if (inputSource === undefined) {
+                    return;
+                }
+
+                inputSource = inputSource.substring(0, index);
+                sourceLines = inputSource.split('\n');
+                sourceColumns = sourceLines[sourceLines.length - 1];
+            }
+
+            lines = chunk.split('\n');
+            columns = lines[lines.length - 1];
+
+            if (fileInfo && fileInfo.filename) {
+                if (!mapLines) {
+                    this._sourceMapGenerator.addMapping({ generated: { line: this._lineNumber + 1, column: this._column},
+                        original: { line: sourceLines.length, column: sourceColumns.length},
+                        source: this.normalizeFilename(fileInfo.filename)});
+                } else {
+                    for (i = 0; i < lines.length; i++) {
+                        this._sourceMapGenerator.addMapping({ generated: { line: this._lineNumber + i + 1, column: i === 0 ? this._column : 0},
+                            original: { line: sourceLines.length + i, column: i === 0 ? sourceColumns.length : 0},
+                            source: this.normalizeFilename(fileInfo.filename)});
+                    }
+                }
+            }
+
+            if (lines.length === 1) {
+                this._column += columns.length;
+            } else {
+                this._lineNumber += lines.length - 1;
+                this._column = columns.length;
+            }
+
+            this._css.push(chunk);
+        }
+
+        isEmpty() {
+            return this._css.length === 0;
+        }
+
+        toCSS(context) {
+            this._sourceMapGenerator = new this._sourceMapGeneratorConstructor({ file: this._outputFilename, sourceRoot: null });
+
+            if (this._outputSourceFiles) {
+                for (const filename in this._contentsMap) {
+                    if (this._contentsMap.hasOwnProperty(filename)) {
+                        let source = this._contentsMap[filename];
+                        if (this._contentsIgnoredCharsMap[filename]) {
+                            source = source.slice(this._contentsIgnoredCharsMap[filename]);
+                        }
+                        this._sourceMapGenerator.setSourceContent(this.normalizeFilename(filename), source);
+                    }
+                }
+            }
+
+            this._rootNode.genCSS(context, this);
+
+            if (this._css.length > 0) {
+                let sourceMapURL;
+                const sourceMapContent = JSON.stringify(this._sourceMapGenerator.toJSON());
+
+                if (this.sourceMapURL) {
+                    sourceMapURL = this.sourceMapURL;
+                } else if (this._sourceMapFilename) {
+                    sourceMapURL = this._sourceMapFilename;
+                }
+                this.sourceMapURL = sourceMapURL;
+
+                this.sourceMap = sourceMapContent;
+            }
+
+            return this._css.join('');
+        }
+    }
+
+    return SourceMapOutput;
+};

package/lib/less/transform-tree.js

@@ -0,0 +1,96 @@
+import contexts from './contexts';
+import visitor from './visitors';
+import tree from './tree';
+
+export default (root, options = {}) => {
+    let evaldRoot;
+    let variables = options.variables;
+    const evalEnv = new contexts.Eval(options);
+
+    //
+    // Allows setting variables with a hash, so:
+    //
+    //   `{ color: new tree.Color('#f01') }` will become:
+    //
+    //   new tree.Declaration('@color',
+    //     new tree.Value([
+    //       new tree.Expression([
+    //         new tree.Color('#f01')
+    //       ])
+    //     ])
+    //   )
+    //
+    if (typeof variables === 'object' && !Array.isArray(variables)) {
+        variables = Object.keys(variables).map(k => {
+            let value = variables[k];
+
+            if (!(value instanceof tree.Value)) {
+                if (!(value instanceof tree.Expression)) {
+                    value = new tree.Expression([value]);
+                }
+                value = new tree.Value([value]);
+            }
+            return new tree.Declaration(`@${k}`, value, false, null, 0);
+        });
+        evalEnv.frames = [new tree.Ruleset(null, variables)];
+    }
+
+    const visitors = [
+        new visitor.JoinSelectorVisitor(),
+        new visitor.MarkVisibleSelectorsVisitor(true),
+        new visitor.ExtendVisitor(),
+        new visitor.ToCSSVisitor({compress: Boolean(options.compress)})
+    ];
+
+    const preEvalVisitors = [];
+    let v;
+    let visitorIterator;
+
+    /**
+     * first() / get() allows visitors to be added while visiting
+     * 
+     * @todo Add scoping for visitors just like functions for @plugin; right now they're global
+     */
+    if (options.pluginManager) {
+        visitorIterator = options.pluginManager.visitor();
+        for (var i = 0; i < 2; i++) {
+            visitorIterator.first();
+            while ((v = visitorIterator.get())) {
+                if (v.isPreEvalVisitor) {
+                    if (i === 0 || preEvalVisitors.indexOf(v) === -1) {
+                        preEvalVisitors.push(v);
+                        v.run(root);
+                    }
+                }
+                else {
+                    if (i === 0 || visitors.indexOf(v) === -1) {
+                        if (v.isPreVisitor) {
+                            visitors.unshift(v);
+                        }
+                        else {
+                            visitors.push(v);
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    evaldRoot = root.eval(evalEnv);
+
+    for (var i = 0; i < visitors.length; i++) {
+        visitors[i].run(evaldRoot);
+    }
+
+    // Run any remaining visitors added after eval pass
+    if (options.pluginManager) {
+        visitorIterator.first();
+        while ((v = visitorIterator.get())) {
+            if (visitors.indexOf(v) === -1 && preEvalVisitors.indexOf(v) === -1) {
+                v.run(evaldRoot);
+            }
+        }
+    }
+
+    return evaldRoot;
+};

package/lib/less/tree/anonymous.js

@@ -0,0 +1,37 @@
+import Node from './node';
+
+class Anonymous extends Node {
+    constructor(value, index, currentFileInfo, mapLines, rulesetLike, visibilityInfo) {
+        super();
+
+        this.value = value;
+        this._index = index;
+        this._fileInfo = currentFileInfo;
+        this.mapLines = mapLines;
+        this.rulesetLike = (typeof rulesetLike === 'undefined') ? false : rulesetLike;
+        this.allowRoot = true;
+        this.copyVisibilityInfo(visibilityInfo);
+    }
+
+    eval() {
+        return new Anonymous(this.value, this._index, this._fileInfo, this.mapLines, this.rulesetLike, this.visibilityInfo());
+    }
+
+    compare(other) {
+        return other.toCSS && this.toCSS() === other.toCSS() ? 0 : undefined;
+    }
+
+    isRulesetLike() {
+        return this.rulesetLike;
+    }
+
+    genCSS(context, output) {
+        this.nodeVisible = Boolean(this.value);
+        if (this.nodeVisible) {
+            output.add(this.value, this._fileInfo, this._index, this.mapLines);
+        }
+    }
+}
+
+Anonymous.prototype.type = 'Anonymous';
+export default Anonymous;

package/lib/less/tree/assignment.js

@@ -0,0 +1,33 @@
+import Node from './node';
+
+class Assignment extends Node {
+    constructor(key, val) {
+        super();
+
+        this.key = key;
+        this.value = val;
+    }
+
+    accept(visitor) {
+        this.value = visitor.visit(this.value);
+    }
+
+    eval(context) {
+        if (this.value.eval) {
+            return new Assignment(this.key, this.value.eval(context));
+        }
+        return this;
+    }
+
+    genCSS(context, output) {
+        output.add(`${this.key}=`);
+        if (this.value.genCSS) {
+            this.value.genCSS(context, output);
+        } else {
+            output.add(this.value);
+        }
+    }
+}
+
+Assignment.prototype.type = 'Assignment';
+export default Assignment;