less 3.10.0-beta.2 → 3.10.3

package/lib/less/environment/abstract-plugin-loader.js

@@ -0,0 +1,187 @@
+import functionRegistry from '../functions/function-registry';
+import LessError from '../less-error';
+
+class AbstractPluginLoader {
+    constructor() {
+        // Implemented by Node.js plugin loader
+        this.require = () => null
+    }
+
+    evalPlugin(contents, context, imports, pluginOptions, fileInfo) {
+        let loader;
+        let registry;
+        let pluginObj;
+        let localModule;
+        let pluginManager;
+        let filename;
+        let result;
+
+        pluginManager = context.pluginManager;
+
+        if (fileInfo) {
+            if (typeof fileInfo === 'string') {
+                filename = fileInfo;
+            }
+            else {
+                filename = fileInfo.filename;
+            }
+        }
+        const shortname = (new this.less.FileManager()).extractUrlParts(filename).filename;
+
+        if (filename) {
+            pluginObj = pluginManager.get(filename);
+
+            if (pluginObj) {
+                result = this.trySetOptions(pluginObj, filename, shortname, pluginOptions);
+                if (result) {
+                    return result;
+                }
+                try {
+                    if (pluginObj.use) {
+                        pluginObj.use.call(this.context, pluginObj);
+                    }
+                }
+                catch (e) {
+                    e.message = e.message || 'Error during @plugin call';
+                    return new LessError(e, imports, filename);
+                }
+                return pluginObj;
+            }
+        }
+        localModule = {
+            exports: {},
+            pluginManager,
+            fileInfo
+        };
+        registry = functionRegistry.create();
+
+        const registerPlugin = obj => {
+            pluginObj = obj;
+        };
+
+        try {
+            loader = new Function('module', 'require', 'registerPlugin', 'functions', 'tree', 'less', 'fileInfo', contents);
+            loader(localModule, this.require(filename), registerPlugin, registry, this.less.tree, this.less, fileInfo);
+        }
+        catch (e) {
+            return new LessError(e, imports, filename);
+        }
+
+        if (!pluginObj) {
+            pluginObj = localModule.exports;
+        }
+        pluginObj = this.validatePlugin(pluginObj, filename, shortname);
+
+        if (pluginObj instanceof LessError) {
+            return pluginObj;
+        }
+
+        if (pluginObj) {
+            pluginObj.imports = imports;
+            pluginObj.filename = filename;
+
+            // For < 3.x (or unspecified minVersion) - setOptions() before install()
+            if (!pluginObj.minVersion || this.compareVersion('3.0.0', pluginObj.minVersion) < 0) {
+                result = this.trySetOptions(pluginObj, filename, shortname, pluginOptions);
+
+                if (result) {
+                    return result;
+                }
+            }
+
+            // Run on first load
+            pluginManager.addPlugin(pluginObj, fileInfo.filename, registry);
+            pluginObj.functions = registry.getLocalFunctions();
+
+            // Need to call setOptions again because the pluginObj might have functions
+            result = this.trySetOptions(pluginObj, filename, shortname, pluginOptions);
+            if (result) {
+                return result;
+            }
+
+            // Run every @plugin call
+            try {
+                if (pluginObj.use) {
+                    pluginObj.use.call(this.context, pluginObj);
+                }
+            }
+            catch (e) {
+                e.message = e.message || 'Error during @plugin call';
+                return new LessError(e, imports, filename);
+            }
+
+        }
+        else {
+            return new LessError({ message: 'Not a valid plugin' }, imports, filename);
+        }
+
+        return pluginObj;
+    }
+
+    trySetOptions(plugin, filename, name, options) {
+        if (options && !plugin.setOptions) {
+            return new LessError({
+                message: `Options have been provided but the plugin ${name} does not support any options.`
+            });
+        }
+        try {
+            plugin.setOptions && plugin.setOptions(options);
+        }
+        catch (e) {
+            return new LessError(e);
+        }
+    }
+
+    validatePlugin(plugin, filename, name) {
+        if (plugin) {
+            // support plugins being a function
+            // so that the plugin can be more usable programmatically
+            if (typeof plugin === 'function') {
+                plugin = new plugin();
+            }
+
+            if (plugin.minVersion) {
+                if (this.compareVersion(plugin.minVersion, this.less.version) < 0) {
+                    return new LessError({
+                        message: `Plugin ${name} requires version ${this.versionToString(plugin.minVersion)}`
+                    });
+                }
+            }
+            return plugin;
+        }
+        return null;
+    }
+
+    compareVersion(aVersion, bVersion) {
+        if (typeof aVersion === 'string') {
+            aVersion = aVersion.match(/^(\d+)\.?(\d+)?\.?(\d+)?/);
+            aVersion.shift();
+        }
+        for (let i = 0; i < aVersion.length; i++) {
+            if (aVersion[i] !== bVersion[i]) {
+                return parseInt(aVersion[i]) > parseInt(bVersion[i]) ? -1 : 1;
+            }
+        }
+        return 0;
+    }
+
+    versionToString(version) {
+        let versionString = '';
+        for (let i = 0; i < version.length; i++) {
+            versionString += (versionString ? '.' : '') + version[i];
+        }
+        return versionString;
+    }
+
+    printUsage(plugins) {
+        for (let i = 0; i < plugins.length; i++) {
+            const plugin = plugins[i];
+            if (plugin.printUsage) {
+                plugin.printUsage();
+            }
+        }
+    }
+}
+
+export default AbstractPluginLoader;
+

package/lib/less/environment/environment-api.js

@@ -0,0 +1,25 @@
+export default {
+    /**
+     * Converts a string to a base 64 string
+     * @param str
+     */
+    encodeBase64: function(str) {
+    },
+    /**
+     * Lookup the mime-type of a filename
+     * @param filename
+     */
+    mimeLookup: function (filename) {
+    },
+    /**
+     * Look up the charset of a mime type
+     * @param mime
+     */
+    charsetLookup: function (mime) {
+    },
+    /**
+     * Gets a source map generator
+     */
+    getSourceMapGenerator: function getSourceMapGenerator() {
+    }
+};

package/lib/less/environment/environment.js

@@ -0,0 +1,59 @@
+/**
+ * @todo Document why this abstraction exists, and the relationship between
+ *       environment, file managers, and plugin manager
+ */
+
+import logger from '../logger';
+
+class environment {
+    constructor(externalEnvironment, fileManagers) {
+        this.fileManagers = fileManagers || [];
+        externalEnvironment = externalEnvironment || {};
+
+        const optionalFunctions = ['encodeBase64', 'mimeLookup', 'charsetLookup', 'getSourceMapGenerator'];
+        const requiredFunctions = [];
+        const functions = requiredFunctions.concat(optionalFunctions);
+
+        for (let i = 0; i < functions.length; i++) {
+            const propName = functions[i];
+            const environmentFunc = externalEnvironment[propName];
+            if (environmentFunc) {
+                this[propName] = environmentFunc.bind(externalEnvironment);
+            } else if (i < requiredFunctions.length) {
+                this.warn(`missing required function in environment - ${propName}`);
+            }
+        }
+    }
+
+    getFileManager(filename, currentDirectory, options, environment, isSync) {
+
+        if (!filename) {
+            logger.warn('getFileManager called with no filename.. Please report this issue. continuing.');
+        }
+        if (currentDirectory == null) {
+            logger.warn('getFileManager called with null directory.. Please report this issue. continuing.');
+        }
+
+        let fileManagers = this.fileManagers;
+        if (options.pluginManager) {
+            fileManagers = [].concat(fileManagers).concat(options.pluginManager.getFileManagers());
+        }
+        for (let i = fileManagers.length - 1; i >= 0 ; i--) {
+            const fileManager = fileManagers[i];
+            if (fileManager[isSync ? 'supportsSync' : 'supports'](filename, currentDirectory, options, environment)) {
+                return fileManager;
+            }
+        }
+        return null;
+    }
+
+    addFileManager(fileManager) {
+        this.fileManagers.push(fileManager);
+    }
+
+    clearFileManagers() {
+        this.fileManagers = [];
+    }
+}
+
+export default environment;

package/lib/less/environment/file-manager-api.js

@@ -0,0 +1,103 @@
+export default {
+    /**
+     * Given the full path to a file, return the path component
+     * Provided by AbstractFileManager
+     * @param {string} filename
+     * @returns {string}
+     */
+    getPath: function(filename) {
+    },
+    /**
+     * Append a .less extension if appropriate. Only called if less thinks one could be added.
+     * Provided by AbstractFileManager
+     * @param filename
+     * @returns {string}
+     */
+    tryAppendLessExtension: function(filename) {
+    },
+    /**
+     * Whether the rootpath should be converted to be absolute.
+     * The browser ovverides this to return true because urls must be absolute.
+     * Provided by AbstractFileManager (returns false)
+     * @returns {bool}
+     */
+    alwaysMakePathsAbsolute: function() {
+    },
+    /**
+     * Returns whether a path is absolute
+     * Provided by AbstractFileManager
+     * @param {string} path
+     * @returns {bool}
+     */
+    isPathAbsolute: function(path) {
+    },
+    /**
+     * joins together 2 paths
+     * Provided by AbstractFileManager
+     * @param {string} basePath
+     * @param {string} laterPath
+     */
+    join: function(basePath, laterPath) {
+    },
+    /**
+     * Returns the difference between 2 paths
+     * E.g. url = a/ baseUrl = a/b/ returns ../
+     * url = a/b/ baseUrl = a/ returns b/
+     * Provided by AbstractFileManager
+     * @param {string} url
+     * @param {string} baseUrl
+     * @returns {string}
+     */
+    pathDiff: function(url, baseUrl) {
+    },
+    /**
+     * Returns whether this file manager supports this file for syncronous file retrieval
+     * If true is returned, loadFileSync will then be called with the file.
+     * Provided by AbstractFileManager (returns false)
+     * @param {string} filename
+     * @param {string} currentDirectory
+     * @param {object} options
+     * @param {less.environment.environment} environment
+     * @returns {bool}
+     */
+    supportsSync: function(filename, currentDirectory, options, environment) {
+    },
+    /**
+     *
+     * @param {string} filename
+     * @param {string} currentDirectory
+     * @param {object} options
+     * @param {less.environment.environment} environment
+     * @returns {bool}
+     */
+    supports: function(filename, currentDirectory, options, environment) {
+    },
+    /**
+     * Loads a file asynchronously. Expects a promise that either rejects with an error or fulfills with an
+     * object containing
+     *  { filename: - full resolved path to file
+     *    contents: - the contents of the file, as a string }
+     *
+     * @param {string} filename
+     * @param {string} currentDirectory
+     * @param {object} options
+     * @param {less.environment.environment} environment
+     * @returns {Promise}
+     */
+    loadFile: function(filename, currentDirectory, options, environment) {
+    },
+    /**
+     * Loads a file synchronously. Expects an immediate return with an object containing
+     *  { error: - error object if an error occurs
+     *    filename: - full resolved path to file
+     *    contents: - the contents of the file, as a string }
+     *
+     * @param {string} filename
+     * @param {string} currentDirectory
+     * @param {object} options
+     * @param {less.environment.environment} environment
+     * @returns {object} should be an object containing error or contents and filename
+     */
+    loadFileSync: function(filename, currentDirectory, options, environment) {
+    }
+};

package/lib/less/functions/boolean.js

@@ -0,0 +1,13 @@
+import Anonymous from '../tree/anonymous';
+import Keyword from '../tree/keyword';
+
+function boolean(condition) {
+    return condition ? Keyword.True : Keyword.False;
+}
+
+function If(condition, trueValue, falseValue) {
+    return condition ? trueValue
+        : (falseValue || new Anonymous);
+}
+
+export default { boolean, 'if': If };

package/lib/less/functions/color-blending.js

@@ -0,0 +1,84 @@
+import Color from '../tree/color';
+
+// Color Blending
+// ref: http://www.w3.org/TR/compositing-1
+
+function colorBlend(mode, color1, color2) {
+    const ab = color1.alpha;        // result
+
+    let // backdrop
+        cb;
+
+    const as = color2.alpha;
+
+    let // source
+        cs;
+
+    let ar;
+    let cr;
+    const r = [];
+
+    ar = as + ab * (1 - as);
+    for (let i = 0; i < 3; i++) {
+        cb = color1.rgb[i] / 255;
+        cs = color2.rgb[i] / 255;
+        cr = mode(cb, cs);
+        if (ar) {
+            cr = (as * cs + ab * (cb -
+                  as * (cb + cs - cr))) / ar;
+        }
+        r[i] = cr * 255;
+    }
+
+    return new Color(r, ar);
+}
+
+const colorBlendModeFunctions = {
+    multiply: function(cb, cs) {
+        return cb * cs;
+    },
+    screen: function(cb, cs) {
+        return cb + cs - cb * cs;
+    },
+    overlay: function(cb, cs) {
+        cb *= 2;
+        return (cb <= 1) ?
+            colorBlendModeFunctions.multiply(cb, cs) :
+            colorBlendModeFunctions.screen(cb - 1, cs);
+    },
+    softlight: function(cb, cs) {
+        let d = 1;
+        let e = cb;
+        if (cs > 0.5) {
+            e = 1;
+            d = (cb > 0.25) ? Math.sqrt(cb)
+                : ((16 * cb - 12) * cb + 4) * cb;
+        }
+        return cb - (1 - 2 * cs) * e * (d - cb);
+    },
+    hardlight: function(cb, cs) {
+        return colorBlendModeFunctions.overlay(cs, cb);
+    },
+    difference: function(cb, cs) {
+        return Math.abs(cb - cs);
+    },
+    exclusion: function(cb, cs) {
+        return cb + cs - 2 * cb * cs;
+    },
+
+    // non-w3c functions:
+    average: function(cb, cs) {
+        return (cb + cs) / 2;
+    },
+    negation: function(cb, cs) {
+        return 1 - Math.abs(cb + cs - 1);
+    }
+};
+
+for (const f in colorBlendModeFunctions) {
+    if (colorBlendModeFunctions.hasOwnProperty(f)) {
+        colorBlend[f] = colorBlend.bind(null, colorBlendModeFunctions[f]);
+    }
+}
+
+export default colorBlend;