less 3.9.0 → 3.10.1

package/lib/less/import-manager.js

@@ -1,12 +1,10 @@
-var contexts = require('./contexts'),
-    Parser = require('./parser/parser'),
-    LessError = require('./less-error'),
-    utils = require('./utils'),
-    PromiseConstructor = typeof Promise === 'undefined' ? require('promise') : Promise,
-    logger = require('./logger');
-
-module.exports = function(environment) {
+import contexts from './contexts';
+import Parser from './parser/parser';
+import LessError from './less-error';
+import * as utils from './utils';
+import logger from './logger';
 
+export default environment => {
     // FileInfo = {
     //  'rewriteUrls' - option - whether to adjust URL's to be relative
     //  'filename' - full resolved filename of current file
@@ -16,152 +14,156 @@ module.exports = function(environment) {
     //  'entryPath' - absolute path to the entry file
     //  'reference' - whether the file should not be output and only output parts that are referenced
 
-    var ImportManager = function(less, context, rootFileInfo) {
-        this.less = less;
-        this.rootFilename = rootFileInfo.filename;
-        this.paths = context.paths || [];  // Search paths, when importing
-        this.contents = {};             // map - filename to contents of all the files
-        this.contentsIgnoredChars = {}; // map - filename to lines at the beginning of each file to ignore
-        this.mime = context.mime;
-        this.error = null;
-        this.context = context;
-        // Deprecated? Unused outside of here, could be useful.
-        this.queue = [];        // Files which haven't been imported yet
-        this.files = {};        // Holds the imported parse trees.
-    };
-
-    /**
-     * Add an import to be imported
-     * @param path - the raw path
-     * @param tryAppendExtension - whether to try appending a file extension (.less or .js if the path has no extension)
-     * @param currentFileInfo - the current file info (used for instance to work out relative paths)
-     * @param importOptions - import options
-     * @param callback - callback for when it is imported
-     */
-    ImportManager.prototype.push = function (path, tryAppendExtension, currentFileInfo, importOptions, callback) {
-        var importManager = this,
-            pluginLoader = this.context.pluginManager.Loader;
-
-        this.queue.push(path);
-
-        var fileParsedFunc = function (e, root, fullPath) {
-            importManager.queue.splice(importManager.queue.indexOf(path), 1); // Remove the path from the queue
-
-            var importedEqualsRoot = fullPath === importManager.rootFilename;
-            if (importOptions.optional && e) {
-                callback(null, {rules:[]}, false, null);
-                logger.info('The file ' + fullPath + ' was skipped because it was not found and the import was marked optional.');
-            }
-            else {
-                // Inline imports aren't cached here.
-                // If we start to cache them, please make sure they won't conflict with non-inline imports of the
-                // same name as they used to do before this comment and the condition below have been added.
-                if (!importManager.files[fullPath] && !importOptions.inline) {
-                    importManager.files[fullPath] = { root: root, options: importOptions };
-                }
-                if (e && !importManager.error) { importManager.error = e; }
-                callback(e, root, importedEqualsRoot, fullPath);
-            }
-        };
-
-        var newFileInfo = {
-            rewriteUrls: this.context.rewriteUrls,
-            entryPath: currentFileInfo.entryPath,
-            rootpath: currentFileInfo.rootpath,
-            rootFilename: currentFileInfo.rootFilename
-        };
-
-        var fileManager = environment.getFileManager(path, currentFileInfo.currentDirectory, this.context, environment);
-
-        if (!fileManager) {
-            fileParsedFunc({ message: 'Could not find a file-manager for ' + path });
-            return;
+    class ImportManager {
+        constructor(less, context, rootFileInfo) {
+            this.less = less;
+            this.rootFilename = rootFileInfo.filename;
+            this.paths = context.paths || [];  // Search paths, when importing
+            this.contents = {};             // map - filename to contents of all the files
+            this.contentsIgnoredChars = {}; // map - filename to lines at the beginning of each file to ignore
+            this.mime = context.mime;
+            this.error = null;
+            this.context = context;
+            // Deprecated? Unused outside of here, could be useful.
+            this.queue = [];        // Files which haven't been imported yet
+            this.files = {};        // Holds the imported parse trees.
         }
 
-        var loadFileCallback = function(loadedFile) {
-            var plugin,
-                resolvedFilename = loadedFile.filename,
-                contents = loadedFile.contents.replace(/^\uFEFF/, '');
-
-            // Pass on an updated rootpath if path of imported file is relative and file
-            // is in a (sub|sup) directory
-            //
-            // Examples:
-            // - If path of imported file is 'module/nav/nav.less' and rootpath is 'less/',
-            //   then rootpath should become 'less/module/nav/'
-            // - If path of imported file is '../mixins.less' and rootpath is 'less/',
-            //   then rootpath should become 'less/../'
-            newFileInfo.currentDirectory = fileManager.getPath(resolvedFilename);
-            if (newFileInfo.rewriteUrls) {
-                newFileInfo.rootpath = fileManager.join(
-                    (importManager.context.rootpath || ''),
-                    fileManager.pathDiff(newFileInfo.currentDirectory, newFileInfo.entryPath));
-
-                if (!fileManager.isPathAbsolute(newFileInfo.rootpath) && fileManager.alwaysMakePathsAbsolute()) {
-                    newFileInfo.rootpath = fileManager.join(newFileInfo.entryPath, newFileInfo.rootpath);
+        /**
+         * Add an import to be imported
+         * @param path - the raw path
+         * @param tryAppendExtension - whether to try appending a file extension (.less or .js if the path has no extension)
+         * @param currentFileInfo - the current file info (used for instance to work out relative paths)
+         * @param importOptions - import options
+         * @param callback - callback for when it is imported
+         */
+        push(path, tryAppendExtension, currentFileInfo, importOptions, callback) {
+            const importManager = this;
+            const pluginLoader = this.context.pluginManager.Loader;
+
+            this.queue.push(path);
+
+            const fileParsedFunc = (e, root, fullPath) => {
+                importManager.queue.splice(importManager.queue.indexOf(path), 1); // Remove the path from the queue
+
+                const importedEqualsRoot = fullPath === importManager.rootFilename;
+                if (importOptions.optional && e) {
+                    callback(null, {rules:[]}, false, null);
+                    logger.info(`The file ${fullPath} was skipped because it was not found and the import was marked optional.`);
                 }
-            }
-            newFileInfo.filename = resolvedFilename;
+                else {
+                    // Inline imports aren't cached here.
+                    // If we start to cache them, please make sure they won't conflict with non-inline imports of the
+                    // same name as they used to do before this comment and the condition below have been added.
+                    if (!importManager.files[fullPath] && !importOptions.inline) {
+                        importManager.files[fullPath] = { root, options: importOptions };
+                    }
+                    if (e && !importManager.error) { importManager.error = e; }
+                    callback(e, root, importedEqualsRoot, fullPath);
+                }
+            };
 
-            var newEnv = new contexts.Parse(importManager.context);
+            const newFileInfo = {
+                rewriteUrls: this.context.rewriteUrls,
+                entryPath: currentFileInfo.entryPath,
+                rootpath: currentFileInfo.rootpath,
+                rootFilename: currentFileInfo.rootFilename
+            };
 
-            newEnv.processImports = false;
-            importManager.contents[resolvedFilename] = contents;
+            const fileManager = environment.getFileManager(path, currentFileInfo.currentDirectory, this.context, environment);
 
-            if (currentFileInfo.reference || importOptions.reference) {
-                newFileInfo.reference = true;
+            if (!fileManager) {
+                fileParsedFunc({ message: `Could not find a file-manager for ${path}` });
+                return;
             }
 
-            if (importOptions.isPlugin) {
-                plugin = pluginLoader.evalPlugin(contents, newEnv, importManager, importOptions.pluginArgs, newFileInfo);
-                if (plugin instanceof LessError) {
-                    fileParsedFunc(plugin, null, resolvedFilename);
-                }
-                else {
-                    fileParsedFunc(null, plugin, resolvedFilename);
+            const loadFileCallback = loadedFile => {
+                let plugin;
+                const resolvedFilename = loadedFile.filename;
+                const contents = loadedFile.contents.replace(/^\uFEFF/, '');
+
+                // Pass on an updated rootpath if path of imported file is relative and file
+                // is in a (sub|sup) directory
+                //
+                // Examples:
+                // - If path of imported file is 'module/nav/nav.less' and rootpath is 'less/',
+                //   then rootpath should become 'less/module/nav/'
+                // - If path of imported file is '../mixins.less' and rootpath is 'less/',
+                //   then rootpath should become 'less/../'
+                newFileInfo.currentDirectory = fileManager.getPath(resolvedFilename);
+                if (newFileInfo.rewriteUrls) {
+                    newFileInfo.rootpath = fileManager.join(
+                        (importManager.context.rootpath || ''),
+                        fileManager.pathDiff(newFileInfo.currentDirectory, newFileInfo.entryPath));
+
+                    if (!fileManager.isPathAbsolute(newFileInfo.rootpath) && fileManager.alwaysMakePathsAbsolute()) {
+                        newFileInfo.rootpath = fileManager.join(newFileInfo.entryPath, newFileInfo.rootpath);
+                    }
                 }
-            } else if (importOptions.inline) {
-                fileParsedFunc(null, contents, resolvedFilename);
-            } else {
+                newFileInfo.filename = resolvedFilename;
 
-                // import (multiple) parse trees apparently get altered and can't be cached.
-                // TODO: investigate why this is
-                if (importManager.files[resolvedFilename]
-                    && !importManager.files[resolvedFilename].options.multiple
-                    && !importOptions.multiple) {
+                const newEnv = new contexts.Parse(importManager.context);
 
-                    fileParsedFunc(null, importManager.files[resolvedFilename].root, resolvedFilename);
-                }
-                else {
-                    new Parser(newEnv, importManager, newFileInfo).parse(contents, function (e, root) {
-                        fileParsedFunc(e, root, resolvedFilename);
-                    });
+                newEnv.processImports = false;
+                importManager.contents[resolvedFilename] = contents;
+
+                if (currentFileInfo.reference || importOptions.reference) {
+                    newFileInfo.reference = true;
                 }
-            }
-        };
-        var promise, context = utils.clone(this.context);
 
-        if (tryAppendExtension) {
-            context.ext = importOptions.isPlugin ? '.js' : '.less';
-        }
+                if (importOptions.isPlugin) {
+                    plugin = pluginLoader.evalPlugin(contents, newEnv, importManager, importOptions.pluginArgs, newFileInfo);
+                    if (plugin instanceof LessError) {
+                        fileParsedFunc(plugin, null, resolvedFilename);
+                    }
+                    else {
+                        fileParsedFunc(null, plugin, resolvedFilename);
+                    }
+                } else if (importOptions.inline) {
+                    fileParsedFunc(null, contents, resolvedFilename);
+                } else {
 
-        if (importOptions.isPlugin) {
-            promise = pluginLoader.loadPlugin(path, currentFileInfo.currentDirectory, context, environment, fileManager);
-        }
-        else {
-            promise = fileManager.loadFile(path, currentFileInfo.currentDirectory, context, environment,
-                function(err, loadedFile) {
-                    if (err) {
-                        fileParsedFunc(err);
-                    } else {
-                        loadFileCallback(loadedFile);
+                    // import (multiple) parse trees apparently get altered and can't be cached.
+                    // TODO: investigate why this is
+                    if (importManager.files[resolvedFilename]
+                        && !importManager.files[resolvedFilename].options.multiple
+                        && !importOptions.multiple) {
+
+                        fileParsedFunc(null, importManager.files[resolvedFilename].root, resolvedFilename);
                     }
-                });
-        }
-        if (promise) {
-            promise.then(loadFileCallback, fileParsedFunc);
+                    else {
+                        new Parser(newEnv, importManager, newFileInfo).parse(contents, (e, root) => {
+                            fileParsedFunc(e, root, resolvedFilename);
+                        });
+                    }
+                }
+            };
+            let promise;
+            const context = utils.clone(this.context);
+
+            if (tryAppendExtension) {
+                context.ext = importOptions.isPlugin ? '.js' : '.less';
+            }
+
+            if (importOptions.isPlugin) {
+                context.mime = 'application/javascript';
+                promise = pluginLoader.loadPlugin(path, currentFileInfo.currentDirectory, context, environment, fileManager);
+            }
+            else {
+                promise = fileManager.loadFile(path, currentFileInfo.currentDirectory, context, environment,
+                    (err, loadedFile) => {
+                        if (err) {
+                            fileParsedFunc(err);
+                        } else {
+                            loadFileCallback(loadedFile);
+                        }
+                    });
+            }
+            if (promise) {
+                promise.then(loadFileCallback, fileParsedFunc);
+            }
         }
+    }
 
-    };
     return ImportManager;
 };

package/lib/less/index.js

@@ -1,42 +1,79 @@
-module.exports = function(environment, fileManagers) {
-    var SourceMapOutput, SourceMapBuilder, ParseTree, ImportManager, Environment;
+import data from './data';
+import tree from './tree';
+import Environment from './environment/environment';
+import AbstractFileManager from './environment/abstract-file-manager';
+import AbstractPluginLoader from './environment/abstract-plugin-loader';
+import visitors from './visitors';
+import Parser from './parser/parser';
+import Functions from './functions';
+import contexts from './contexts';
+import sourceMapOutput from './source-map-output';
+import sourceMapBuilder from './source-map-builder';
+import parseTree from './parse-tree';
+import importManager from './import-manager';
+import Render from './render';
+import Parse from './parse';
+import LessError from './less-error';
+import transformTree from './transform-tree';
+import * as utils from './utils';
+import PluginManager from './plugin-manager';
+import logger from './logger';
 
-    var initial = {
-        version: [3, 9, 0],
-        data: require('./data'),
-        tree: require('./tree'),
-        Environment: (Environment = require('./environment/environment')),
-        AbstractFileManager: require('./environment/abstract-file-manager'),
-        AbstractPluginLoader: require('./environment/abstract-plugin-loader'),
-        environment: (environment = new Environment(environment, fileManagers)),
-        visitors: require('./visitors'),
-        Parser: require('./parser/parser'),
-        functions: require('./functions')(environment),
-        contexts: require('./contexts'),
-        SourceMapOutput: (SourceMapOutput = require('./source-map-output')(environment)),
-        SourceMapBuilder: (SourceMapBuilder = require('./source-map-builder')(SourceMapOutput, environment)),
-        ParseTree: (ParseTree = require('./parse-tree')(SourceMapBuilder)),
-        ImportManager: (ImportManager = require('./import-manager')(environment)),
-        render: require('./render')(environment, ParseTree, ImportManager),
-        parse: require('./parse')(environment, ParseTree, ImportManager),
-        LessError: require('./less-error'),
-        transformTree: require('./transform-tree'),
-        utils: require('./utils'),
-        PluginManager: require('./plugin-manager'),
-        logger: require('./logger')
+export default (environment, fileManagers) => {
+    /**
+     * @todo
+     * This original code could be improved quite a bit.
+     * Many classes / modules currently add side-effects / mutations to passed in objects,
+     * which makes it hard to refactor and reason about. 
+     */
+    environment = new Environment(environment, fileManagers);
+
+    const SourceMapOutput = sourceMapOutput(environment);
+    const SourceMapBuilder = sourceMapBuilder(SourceMapOutput, environment);
+    const ParseTree = parseTree(SourceMapBuilder);
+    const ImportManager = importManager(environment);
+    const render = Render(environment, ParseTree, ImportManager);
+    const parse = Parse(environment, ParseTree, ImportManager);
+    const functions = Functions(environment);
+
+    /**
+     * @todo
+     * This root properties / methods need to be organized.
+     * It's not clear what should / must be public and why.
+     */
+    const initial = {
+        version: [3, 10, 1],
+        data,
+        tree,
+        Environment,
+        AbstractFileManager,
+        AbstractPluginLoader,
+        environment,
+        visitors,
+        Parser,
+        functions,
+        contexts,
+        SourceMapOutput,
+        SourceMapBuilder,
+        ParseTree,
+        ImportManager,
+        render,
+        parse,
+        LessError,
+        transformTree,
+        utils,
+        PluginManager,
+        logger
     };
 
     // Create a public API
-
-    var ctor = function(t) {
-        return function() {
-            var obj = Object.create(t.prototype);
-            t.apply(obj, Array.prototype.slice.call(arguments, 0));
-            return obj;
-        };
+    const ctor = t => function (...args) {
+        return new t(...args);
     };
-    var t, api = Object.create(initial);
-    for (var n in initial.tree) {
+
+    let t;
+    const api = Object.create(initial);
+    for (const n in initial.tree) {
         /* eslint guard-for-in: 0 */
         t = initial.tree[n];
         if (typeof t === 'function') {
@@ -44,7 +81,7 @@ module.exports = function(environment, fileManagers) {
         }
         else {
             api[n] = Object.create(null);
-            for (var o in t) {
+            for (const o in t) {
                 /* eslint guard-for-in: 0 */
                 api[n][o.toLowerCase()] = ctor(t[o]);
             }

package/lib/less/less-error.js

@@ -1,4 +1,4 @@
-var utils = require('./utils');
+import * as utils from './utils';
 /**
  * This is a centralized class of any error that could be thrown internally (mostly by the parser).
  * Besides standard .message it keeps some additional data like a path to the file where the error
@@ -21,21 +21,21 @@ var utils = require('./utils');
  * @param {Object} fileContentMap - An object with file contents in 'contents' property (like importManager) @todo - move to fileManager?
  * @param {string} [currentFilename]
  */
-var LessError = module.exports = function LessError(e, fileContentMap, currentFilename) {
+const LessError = function LessError(e, fileContentMap, currentFilename) {
     Error.call(this);
 
-    var filename = e.filename || currentFilename;
+    const filename = e.filename || currentFilename;
 
     this.message = e.message;
     this.stack = e.stack;
 
     if (fileContentMap && filename) {
-        var input = fileContentMap.contents[filename],
-            loc = utils.getLocation(e.index, input),
-            line = loc.line,
-            col  = loc.column,
-            callLine = e.call && utils.getLocation(e.call, input).line,
-            lines = input ? input.split('\n') : '';
+        const input = fileContentMap.contents[filename];
+        const loc = utils.getLocation(e.index, input);
+        const line = loc.line;
+        const col  = loc.column;
+        const callLine = e.call && utils.getLocation(e.call, input).line;
+        const lines = input ? input.split('\n') : '';
 
         this.type = e.type || 'Syntax';
         this.filename = filename;
@@ -44,7 +44,7 @@ var LessError = module.exports = function LessError(e, fileContentMap, currentFi
         this.column = col;
 
         if (!this.line && this.stack) {
-            var found = this.stack.match(/(<anonymous>|Function):(\d+):(\d+)/);
+            const found = this.stack.match(/(<anonymous>|Function):(\d+):(\d+)/);
 
             if (found) {
                 if (found[2]) {
@@ -64,13 +64,12 @@ var LessError = module.exports = function LessError(e, fileContentMap, currentFi
             lines[this.line - 1],
             lines[this.line]
         ];
-
     }
 
 };
 
 if (typeof Object.create === 'undefined') {
-    var F = function () {};
+    const F = () => {};
     F.prototype = Error.prototype;
     LessError.prototype = new F();
 } else {
@@ -86,28 +85,26 @@ LessError.prototype.constructor = LessError;
  * @param {Object} options
  * @returns {string}
  */
-LessError.prototype.toString = function(options) {
-    options = options || {};
-
-    var message = '';
-    var extract = this.extract || [];
-    var error = [];
-    var stylize = function (str) { return str; };
+LessError.prototype.toString = function(options = {}) {
+    let message = '';
+    const extract = this.extract || [];
+    let error = [];
+    let stylize = str => str;
     if (options.stylize) {
-        var type = typeof options.stylize;
+        const type = typeof options.stylize;
         if (type !== 'function') {
-            throw Error('options.stylize should be a function, got a ' + type + '!');
+            throw Error(`options.stylize should be a function, got a ${type}!`);
         }
         stylize = options.stylize;
     }
 
     if (this.line !== null) {
         if (typeof extract[0] === 'string') {
-            error.push(stylize((this.line - 1) + ' ' + extract[0], 'grey'));
+            error.push(stylize(`${this.line - 1} ${extract[0]}`, 'grey'));
         }
 
         if (typeof extract[1] === 'string') {
-            var errorTxt = this.line + ' ';
+            let errorTxt = `${this.line} `;
             if (extract[1]) {
                 errorTxt += extract[1].slice(0, this.column) +
                     stylize(stylize(stylize(extract[1].substr(this.column, 1), 'bold') +
@@ -117,25 +114,27 @@ LessError.prototype.toString = function(options) {
         }
 
         if (typeof extract[2] === 'string') {
-            error.push(stylize((this.line + 1) + ' ' + extract[2], 'grey'));
+            error.push(stylize(`${this.line + 1} ${extract[2]}`, 'grey'));
         }
-        error = error.join('\n') + stylize('', 'reset') + '\n';
+        error = `${error.join('\n') + stylize('', 'reset')}\n`;
     }
 
-    message += stylize(this.type + 'Error: ' + this.message, 'red');
+    message += stylize(`${this.type}Error: ${this.message}`, 'red');
     if (this.filename) {
         message += stylize(' in ', 'red') + this.filename;
     }
     if (this.line) {
-        message += stylize(' on line ' + this.line + ', column ' + (this.column + 1) + ':', 'grey');
+        message += stylize(` on line ${this.line}, column ${this.column + 1}:`, 'grey');
     }
 
-    message += '\n' + error;
+    message += `\n${error}`;
 
     if (this.callLine) {
-        message += stylize('from ', 'red') + (this.filename || '') + '/n';
-        message += stylize(this.callLine, 'grey') + ' ' + this.callExtract + '/n';
+        message += `${stylize('from ', 'red') + (this.filename || '')}/n`;
+        message += `${stylize(this.callLine, 'grey')} ${this.callExtract}/n`;
     }
 
     return message;
 };
+
+export default LessError;

package/lib/less/logger.js

@@ -1,4 +1,4 @@
-module.exports = {
+export default {
     error: function(msg) {
         this._fireEvent('error', msg);
     },
@@ -15,7 +15,7 @@ module.exports = {
         this._listeners.push(listener);
     },
     removeListener: function(listener) {
-        for (var i = 0; i < this._listeners.length; i++) {
+        for (let i = 0; i < this._listeners.length; i++) {
             if (this._listeners[i] === listener) {
                 this._listeners.splice(i, 1);
                 return;
@@ -23,8 +23,8 @@ module.exports = {
         }
     },
     _fireEvent: function(type, msg) {
-        for (var i = 0; i < this._listeners.length; i++) {
-            var logFunction = this._listeners[i][type];
+        for (let i = 0; i < this._listeners.length; i++) {
+            const logFunction = this._listeners[i][type];
             if (logFunction) {
                 logFunction(msg);
             }