less-execjs 2.6.0.3

data/lib/less/js/less/lib/less-browser/cache.js

@@ -0,0 +1,42 @@
+// Cache system is a bit outdated and could do with work
+
+module.exports = function(window, options, logger) {
+    var cache = null;
+    if (options.env !== 'development') {
+        try {
+            cache = (typeof window.localStorage === 'undefined') ? null : window.localStorage;
+        } catch (_) {}
+    }
+    return {
+        setCSS: function(path, lastModified, modifyVars, styles) {
+            if (cache) {
+                logger.info('saving ' + path + ' to cache.');
+                try {
+                    cache.setItem(path, styles);
+                    cache.setItem(path + ':timestamp', lastModified);
+                    if (modifyVars) {
+                        cache.setItem(path + ':vars', JSON.stringify(modifyVars));
+                    }
+                } catch(e) {
+                    //TODO - could do with adding more robust error handling
+                    logger.error('failed to save "' + path + '" to local storage for caching.');
+                }
+            }
+        },
+        getCSS: function(path, webInfo, modifyVars) {
+            var css       = cache && cache.getItem(path),
+                timestamp = cache && cache.getItem(path + ':timestamp'),
+                vars      = cache && cache.getItem(path + ':vars');
+
+            modifyVars = modifyVars || {};
+
+            if (timestamp && webInfo.lastModified &&
+                (new Date(webInfo.lastModified).valueOf() ===
+                    new Date(timestamp).valueOf()) &&
+                (!modifyVars && !vars || JSON.stringify(modifyVars) === vars)) {
+                // Use local copy
+                return css;
+            }
+        }
+    };
+};

data/lib/less/js/less/lib/less-browser/error-reporting.js

@@ -0,0 +1,170 @@
+var utils = require("./utils"),
+    browser = require("./browser");
+
+module.exports = function(window, less, options) {
+
+    function errorHTML(e, rootHref) {
+        var id = 'less-error-message:' + utils.extractId(rootHref || "");
+        var template = '<li><label>{line}</label><pre class="{class}">{content}</pre></li>';
+        var elem = window.document.createElement('div'), timer, content, errors = [];
+        var filename = e.filename || rootHref;
+        var filenameNoPath = filename.match(/([^\/]+(\?.*)?)$/)[1];
+
+        elem.id        = id;
+        elem.className = "less-error-message";
+
+        content = '<h3>'  + (e.type || "Syntax") + "Error: " + (e.message || 'There is an error in your .less file') +
+            '</h3>' + '<p>in <a href="' + filename   + '">' + filenameNoPath + "</a> ";
+
+        var errorline = function (e, i, classname) {
+            if (e.extract[i] !== undefined) {
+                errors.push(template.replace(/\{line\}/, (parseInt(e.line, 10) || 0) + (i - 1))
+                    .replace(/\{class\}/, classname)
+                    .replace(/\{content\}/, e.extract[i]));
+            }
+        };
+
+        if (e.extract) {
+            errorline(e, 0, '');
+            errorline(e, 1, 'line');
+            errorline(e, 2, '');
+            content += 'on line ' + e.line + ', column ' + (e.column + 1) + ':</p>' +
+                '<ul>' + errors.join('') + '</ul>';
+        }
+        if (e.stack && (e.extract || options.logLevel >= 4)) {
+            content += '<br/>Stack Trace</br />' + e.stack.split('\n').slice(1).join('<br/>');
+        }
+        elem.innerHTML = content;
+
+        // CSS for error messages
+        browser.createCSS(window.document, [
+            '.less-error-message ul, .less-error-message li {',
+            'list-style-type: none;',
+            'margin-right: 15px;',
+            'padding: 4px 0;',
+            'margin: 0;',
+            '}',
+            '.less-error-message label {',
+            'font-size: 12px;',
+            'margin-right: 15px;',
+            'padding: 4px 0;',
+            'color: #cc7777;',
+            '}',
+            '.less-error-message pre {',
+            'color: #dd6666;',
+            'padding: 4px 0;',
+            'margin: 0;',
+            'display: inline-block;',
+            '}',
+            '.less-error-message pre.line {',
+            'color: #ff0000;',
+            '}',
+            '.less-error-message h3 {',
+            'font-size: 20px;',
+            'font-weight: bold;',
+            'padding: 15px 0 5px 0;',
+            'margin: 0;',
+            '}',
+            '.less-error-message a {',
+            'color: #10a',
+            '}',
+            '.less-error-message .error {',
+            'color: red;',
+            'font-weight: bold;',
+            'padding-bottom: 2px;',
+            'border-bottom: 1px dashed red;',
+            '}'
+        ].join('\n'), { title: 'error-message' });
+
+        elem.style.cssText = [
+            "font-family: Arial, sans-serif",
+            "border: 1px solid #e00",
+            "background-color: #eee",
+            "border-radius: 5px",
+            "-webkit-border-radius: 5px",
+            "-moz-border-radius: 5px",
+            "color: #e00",
+            "padding: 15px",
+            "margin-bottom: 15px"
+        ].join(';');
+
+        if (options.env === 'development') {
+            timer = setInterval(function () {
+                var document = window.document,
+                    body = document.body;
+                if (body) {
+                    if (document.getElementById(id)) {
+                        body.replaceChild(elem, document.getElementById(id));
+                    } else {
+                        body.insertBefore(elem, body.firstChild);
+                    }
+                    clearInterval(timer);
+                }
+            }, 10);
+        }
+    }
+
+    function removeErrorHTML(path) {
+        var node = window.document.getElementById('less-error-message:' + utils.extractId(path));
+        if (node) {
+            node.parentNode.removeChild(node);
+        }
+    }
+
+    function removeErrorConsole(path) {
+        //no action
+    }
+
+    function removeError(path) {
+        if (!options.errorReporting || options.errorReporting === "html") {
+            removeErrorHTML(path);
+        } else if (options.errorReporting === "console") {
+            removeErrorConsole(path);
+        } else if (typeof options.errorReporting === 'function') {
+            options.errorReporting("remove", path);
+        }
+    }
+
+    function errorConsole(e, rootHref) {
+        var template = '{line} {content}';
+        var filename = e.filename || rootHref;
+        var errors = [];
+        var content = (e.type || "Syntax") + "Error: " + (e.message || 'There is an error in your .less file') +
+            " in " + filename + " ";
+
+        var errorline = function (e, i, classname) {
+            if (e.extract[i] !== undefined) {
+                errors.push(template.replace(/\{line\}/, (parseInt(e.line, 10) || 0) + (i - 1))
+                    .replace(/\{class\}/, classname)
+                    .replace(/\{content\}/, e.extract[i]));
+            }
+        };
+
+        if (e.extract) {
+            errorline(e, 0, '');
+            errorline(e, 1, 'line');
+            errorline(e, 2, '');
+            content += 'on line ' + e.line + ', column ' + (e.column + 1) + ':\n' +
+                errors.join('\n');
+        }
+        if (e.stack && (e.extract || options.logLevel >= 4)) {
+            content += '\nStack Trace\n' + e.stack;
+        }
+        less.logger.error(content);
+    }
+
+    function error(e, rootHref) {
+        if (!options.errorReporting || options.errorReporting === "html") {
+            errorHTML(e, rootHref);
+        } else if (options.errorReporting === "console") {
+            errorConsole(e, rootHref);
+        } else if (typeof options.errorReporting === 'function') {
+            options.errorReporting("add", e, rootHref);
+        }
+    }
+
+    return {
+        add: error,
+        remove: removeError
+    };
+};

data/lib/less/js/less/lib/less-browser/file-manager.js

@@ -0,0 +1,119 @@
+/*global window, XMLHttpRequest */
+
+module.exports = function(options, logger) {
+
+    var AbstractFileManager = require("../less/environment/abstract-file-manager.js");
+
+    var fileCache = {};
+
+    //TODOS - move log somewhere. pathDiff and doing something similar in node. use pathDiff in the other browser file for the initial load
+
+    function getXMLHttpRequest() {
+        if (window.XMLHttpRequest && (window.location.protocol !== "file:" || !("ActiveXObject" in window))) {
+            return new XMLHttpRequest();
+        } else {
+            try {
+                /*global ActiveXObject */
+                return new ActiveXObject("Microsoft.XMLHTTP");
+            } catch (e) {
+                logger.error("browser doesn't support AJAX.");
+                return null;
+            }
+        }
+    }
+
+    var FileManager = function() {
+    };
+
+    FileManager.prototype = new AbstractFileManager();
+
+    FileManager.prototype.alwaysMakePathsAbsolute = function alwaysMakePathsAbsolute() {
+        return true;
+    };
+    FileManager.prototype.join = function join(basePath, laterPath) {
+        if (!basePath) {
+            return laterPath;
+        }
+        return this.extractUrlParts(laterPath, basePath).path;
+    };
+    FileManager.prototype.doXHR = function doXHR(url, type, callback, errback) {
+
+        var xhr = getXMLHttpRequest();
+        var async = options.isFileProtocol ? options.fileAsync : true;
+
+        if (typeof xhr.overrideMimeType === 'function') {
+            xhr.overrideMimeType('text/css');
+        }
+        logger.debug("XHR: Getting '" + url + "'");
+        xhr.open('GET', url, async);
+        xhr.setRequestHeader('Accept', type || 'text/x-less, text/css; q=0.9, */*; q=0.5');
+        xhr.send(null);
+
+        function handleResponse(xhr, callback, errback) {
+            if (xhr.status >= 200 && xhr.status < 300) {
+                callback(xhr.responseText,
+                    xhr.getResponseHeader("Last-Modified"));
+            } else if (typeof errback === 'function') {
+                errback(xhr.status, url);
+            }
+        }
+
+        if (options.isFileProtocol && !options.fileAsync) {
+            if (xhr.status === 0 || (xhr.status >= 200 && xhr.status < 300)) {
+                callback(xhr.responseText);
+            } else {
+                errback(xhr.status, url);
+            }
+        } else if (async) {
+            xhr.onreadystatechange = function () {
+                if (xhr.readyState == 4) {
+                    handleResponse(xhr, callback, errback);
+                }
+            };
+        } else {
+            handleResponse(xhr, callback, errback);
+        }
+    };
+    FileManager.prototype.supports = function(filename, currentDirectory, options, environment) {
+        return true;
+    };
+
+    FileManager.prototype.clearFileCache = function() {
+        fileCache = {};
+    };
+
+    FileManager.prototype.loadFile = function loadFile(filename, currentDirectory, options, environment, callback) {
+        if (currentDirectory && !this.isPathAbsolute(filename)) {
+            filename = currentDirectory + filename;
+        }
+
+        options = options || {};
+
+        // sheet may be set to the stylesheet for the initial load or a collection of properties including
+        // some context variables for imports
+        var hrefParts = this.extractUrlParts(filename, window.location.href);
+        var href      = hrefParts.url;
+
+        if (options.useFileCache && fileCache[href]) {
+            try {
+                var lessText = fileCache[href];
+                callback(null, { contents: lessText, filename: href, webInfo: { lastModified: new Date() }});
+            } catch (e) {
+                callback({filename: href, message: "Error loading file " + href + " error was " + e.message});
+            }
+            return;
+        }
+
+        this.doXHR(href, options.mime, function doXHRCallback(data, lastModified) {
+            // per file cache
+            fileCache[href] = data;
+
+            // Use remote copy (re-parse)
+            callback(null, { contents: data, filename: href, webInfo: { lastModified: lastModified }});
+        }, function doXHRError(status, url) {
+            callback({ type: 'File', message: "'" + url + "' wasn't found (" + status + ")", href: href });
+        });
+    };
+
+    return FileManager;
+};

data/lib/less/js/less/lib/less-browser/image-size.js

@@ -0,0 +1,28 @@
+module.exports = function() {
+
+    var functionRegistry = require("./../less/functions/function-registry");
+
+    function imageSize() {
+        throw {
+            type: "Runtime",
+            message: "Image size functions are not supported in browser version of less"
+        };
+    }
+
+    var imageFunctions = {
+        "image-size": function(filePathNode) {
+            imageSize(this, filePathNode);
+            return -1;
+        },
+        "image-width": function(filePathNode) {
+            imageSize(this, filePathNode);
+            return -1;
+        },
+        "image-height": function(filePathNode) {
+            imageSize(this, filePathNode);
+            return -1;
+        }
+    };
+
+    functionRegistry.addMultiple(imageFunctions);
+};

data/lib/less/js/less/lib/less-browser/index.js

@@ -0,0 +1,263 @@
+//
+// index.js
+// Should expose the additional browser functions on to the less object
+//
+var addDataAttr = require("./utils").addDataAttr,
+    browser = require("./browser");
+
+module.exports = function(window, options) {
+    var document = window.document;
+    var less = require('../less')();
+
+    //module.exports = less;
+    less.options = options;
+    var environment = less.environment,
+        FileManager = require("./file-manager")(options, less.logger),
+        fileManager = new FileManager();
+    environment.addFileManager(fileManager);
+    less.FileManager = FileManager;
+
+    require("./log-listener")(less, options);
+    var errors = require("./error-reporting")(window, less, options);
+    var cache = less.cache = options.cache || require("./cache")(window, options, less.logger);
+    require('./image-size')(less.environment);
+
+    //Setup user functions
+    if (options.functions) {
+        less.functions.functionRegistry.addMultiple(options.functions);
+    }
+
+    var typePattern = /^text\/(x-)?less$/;
+
+    function postProcessCSS(styles) { // deprecated, use a plugin for postprocesstasks
+        if (options.postProcessor && typeof options.postProcessor === 'function') {
+            styles = options.postProcessor.call(styles, styles) || styles;
+        }
+        return styles;
+    }
+
+    function clone(obj) {
+        var cloned = {};
+        for (var prop in obj) {
+            if (obj.hasOwnProperty(prop)) {
+                cloned[prop] = obj[prop];
+            }
+        }
+        return cloned;
+    }
+
+    // only really needed for phantom
+    function bind(func, thisArg) {
+        var curryArgs = Array.prototype.slice.call(arguments, 2);
+        return function() {
+            var args = curryArgs.concat(Array.prototype.slice.call(arguments, 0));
+            return func.apply(thisArg, args);
+        };
+    }
+
+    function loadStyles(modifyVars) {
+        var styles = document.getElementsByTagName('style'),
+            style;
+
+        for (var i = 0; i < styles.length; i++) {
+            style = styles[i];
+            if (style.type.match(typePattern)) {
+                var instanceOptions = clone(options);
+                instanceOptions.modifyVars = modifyVars;
+                var lessText = style.innerHTML || '';
+                instanceOptions.filename = document.location.href.replace(/#.*$/, '');
+
+                /*jshint loopfunc:true */
+                // use closure to store current style
+                less.render(lessText, instanceOptions,
+                        bind(function(style, e, result) {
+                            if (e) {
+                                errors.add(e, "inline");
+                            } else {
+                                style.type = 'text/css';
+                                if (style.styleSheet) {
+                                    style.styleSheet.cssText = result.css;
+                                } else {
+                                    style.innerHTML = result.css;
+                                }
+                            }
+                        }, null, style));
+            }
+        }
+    }
+
+    function loadStyleSheet(sheet, callback, reload, remaining, modifyVars) {
+
+        var instanceOptions = clone(options);
+        addDataAttr(instanceOptions, sheet);
+        instanceOptions.mime = sheet.type;
+
+        if (modifyVars) {
+            instanceOptions.modifyVars = modifyVars;
+        }
+
+        function loadInitialFileCallback(loadedFile) {
+
+            var data = loadedFile.contents,
+                path = loadedFile.filename,
+                webInfo = loadedFile.webInfo;
+
+            var newFileInfo = {
+                currentDirectory: fileManager.getPath(path),
+                filename: path,
+                rootFilename: path,
+                relativeUrls: instanceOptions.relativeUrls};
+
+            newFileInfo.entryPath = newFileInfo.currentDirectory;
+            newFileInfo.rootpath = instanceOptions.rootpath || newFileInfo.currentDirectory;
+
+            if (webInfo) {
+                webInfo.remaining = remaining;
+
+                var css = cache.getCSS(path, webInfo, instanceOptions.modifyVars);
+                if (!reload && css) {
+                    webInfo.local = true;
+                    callback(null, css, data, sheet, webInfo, path);
+                    return;
+                }
+
+            }
+
+            //TODO add tests around how this behaves when reloading
+            errors.remove(path);
+
+            instanceOptions.rootFileInfo = newFileInfo;
+            less.render(data, instanceOptions, function(e, result) {
+                if (e) {
+                    e.href = path;
+                    callback(e);
+                } else {
+                    result.css = postProcessCSS(result.css);
+                    cache.setCSS(sheet.href, webInfo.lastModified, instanceOptions.modifyVars, result.css);
+                    callback(null, result.css, data, sheet, webInfo, path);
+                }
+            });
+        }
+
+        fileManager.loadFile(sheet.href, null, instanceOptions, environment, function(e, loadedFile) {
+            if (e) {
+                callback(e);
+                return;
+            }
+            loadInitialFileCallback(loadedFile);
+        });
+    }
+
+    function loadStyleSheets(callback, reload, modifyVars) {
+        for (var i = 0; i < less.sheets.length; i++) {
+            loadStyleSheet(less.sheets[i], callback, reload, less.sheets.length - (i + 1), modifyVars);
+        }
+    }
+
+    function initRunningMode() {
+        if (less.env === 'development') {
+            less.watchTimer = setInterval(function () {
+                if (less.watchMode) {
+                    fileManager.clearFileCache();
+                    loadStyleSheets(function (e, css, _, sheet, webInfo) {
+                        if (e) {
+                            errors.add(e, e.href || sheet.href);
+                        } else if (css) {
+                            browser.createCSS(window.document, css, sheet);
+                        }
+                    });
+                }
+            }, options.poll);
+        }
+    }
+
+    //
+    // Watch mode
+    //
+    less.watch   = function () {
+        if (!less.watchMode ) {
+            less.env = 'development';
+            initRunningMode();
+        }
+        this.watchMode = true;
+        return true;
+    };
+
+    less.unwatch = function () {clearInterval(less.watchTimer); this.watchMode = false; return false; };
+
+    //
+    // Synchronously get all <link> tags with the 'rel' attribute set to
+    // "stylesheet/less".
+    //
+    less.registerStylesheetsImmediately = function() {
+        var links = document.getElementsByTagName('link');
+        less.sheets = [];
+
+        for (var i = 0; i < links.length; i++) {
+            if (links[i].rel === 'stylesheet/less' || (links[i].rel.match(/stylesheet/) &&
+                (links[i].type.match(typePattern)))) {
+                less.sheets.push(links[i]);
+            }
+        }
+    };
+
+    //
+    // Asynchronously get all <link> tags with the 'rel' attribute set to
+    // "stylesheet/less", returning a Promise.
+    //
+    less.registerStylesheets = function() {
+        return new Promise(function(resolve, reject) {
+            less.registerStylesheetsImmediately();
+            resolve();
+        });
+    };
+
+    //
+    // With this function, it's possible to alter variables and re-render
+    // CSS without reloading less-files
+    //
+    less.modifyVars = function(record) {
+        return less.refresh(true, record, false);
+    };
+
+    less.refresh = function (reload, modifyVars, clearFileCache) {
+        if ((reload || clearFileCache) && clearFileCache !== false) {
+            fileManager.clearFileCache();
+        }
+        return new Promise(function (resolve, reject) {
+            var startTime, endTime, totalMilliseconds;
+            startTime = endTime = new Date();
+
+            loadStyleSheets(function (e, css, _, sheet, webInfo) {
+                if (e) {
+                    errors.add(e, e.href || sheet.href);
+                    reject(e);
+                    return;
+                }
+                if (webInfo.local) {
+                    less.logger.info("loading " + sheet.href + " from cache.");
+                } else {
+                    less.logger.info("rendered " + sheet.href + " successfully.");
+                }
+                browser.createCSS(window.document, css, sheet);
+                less.logger.info("css for " + sheet.href + " generated in " + (new Date() - endTime) + 'ms');
+                if (webInfo.remaining === 0) {
+                    totalMilliseconds = new Date() - startTime;
+                    less.logger.info("less has finished. css generated in " + totalMilliseconds + 'ms');
+                    resolve({
+                        startTime: startTime,
+                        endTime: endTime,
+                        totalMilliseconds: totalMilliseconds,
+                        sheets: less.sheets.length
+                    });
+                }
+                endTime = new Date();
+            }, reload, modifyVars);
+
+            loadStyles(modifyVars);
+        });
+    };
+
+    less.refreshStyles = loadStyles;
+    return less;
+};