less 3.10.0-beta.2 → 3.10.3

package/lib/less/visitors/visitor.js

@@ -0,0 +1,163 @@
+import tree from '../tree';
+const _visitArgs = { visitDeeper: true };
+let _hasIndexed = false;
+
+function _noop(node) {
+    return node;
+}
+
+function indexNodeTypes(parent, ticker) {
+    // add .typeIndex to tree node types for lookup table
+    let key;
+
+    let child;
+    for (key in parent) { 
+        /* eslint guard-for-in: 0 */
+        child = parent[key];
+        switch (typeof child) {
+            case 'function':
+                // ignore bound functions directly on tree which do not have a prototype
+                // or aren't nodes
+                if (child.prototype && child.prototype.type) {
+                    child.prototype.typeIndex = ticker++;
+                }
+                break;
+            case 'object':
+                ticker = indexNodeTypes(child, ticker);
+                break;
+        
+        }
+    }
+    return ticker;
+}
+
+class Visitor {
+    constructor(implementation) {
+        this._implementation = implementation;
+        this._visitInCache = {};
+        this._visitOutCache = {};
+
+        if (!_hasIndexed) {
+            indexNodeTypes(tree, 1);
+            _hasIndexed = true;
+        }
+    }
+
+    visit(node) {
+        if (!node) {
+            return node;
+        }
+
+        const nodeTypeIndex = node.typeIndex;
+        if (!nodeTypeIndex) {
+            // MixinCall args aren't a node type?
+            if (node.value && node.value.typeIndex) {
+                this.visit(node.value);
+            }
+            return node;
+        }
+
+        const impl = this._implementation;
+        let func = this._visitInCache[nodeTypeIndex];
+        let funcOut = this._visitOutCache[nodeTypeIndex];
+        const visitArgs = _visitArgs;
+        let fnName;
+
+        visitArgs.visitDeeper = true;
+
+        if (!func) {
+            fnName = `visit${node.type}`;
+            func = impl[fnName] || _noop;
+            funcOut = impl[`${fnName}Out`] || _noop;
+            this._visitInCache[nodeTypeIndex] = func;
+            this._visitOutCache[nodeTypeIndex] = funcOut;
+        }
+
+        if (func !== _noop) {
+            const newNode = func.call(impl, node, visitArgs);
+            if (node && impl.isReplacing) {
+                node = newNode;
+            }
+        }
+
+        if (visitArgs.visitDeeper && node && node.accept) {
+            node.accept(this);
+        }
+
+        if (funcOut != _noop) {
+            funcOut.call(impl, node);
+        }
+
+        return node;
+    }
+
+    visitArray(nodes, nonReplacing) {
+        if (!nodes) {
+            return nodes;
+        }
+
+        const cnt = nodes.length;
+        let i;
+
+        // Non-replacing
+        if (nonReplacing || !this._implementation.isReplacing) {
+            for (i = 0; i < cnt; i++) {
+                this.visit(nodes[i]);
+            }
+            return nodes;
+        }
+
+        // Replacing
+        const out = [];
+        for (i = 0; i < cnt; i++) {
+            const evald = this.visit(nodes[i]);
+            if (evald === undefined) { continue; }
+            if (!evald.splice) {
+                out.push(evald);
+            } else if (evald.length) {
+                this.flatten(evald, out);
+            }
+        }
+        return out;
+    }
+
+    flatten(arr, out) {
+        if (!out) {
+            out = [];
+        }
+
+        let cnt;
+        let i;
+        let item;
+        let nestedCnt;
+        let j;
+        let nestedItem;
+
+        for (i = 0, cnt = arr.length; i < cnt; i++) {
+            item = arr[i];
+            if (item === undefined) {
+                continue;
+            }
+            if (!item.splice) {
+                out.push(item);
+                continue;
+            }
+
+            for (j = 0, nestedCnt = item.length; j < nestedCnt; j++) {
+                nestedItem = item[j];
+                if (nestedItem === undefined) {
+                    continue;
+                }
+                if (!nestedItem.splice) {
+                    out.push(nestedItem);
+                } else if (nestedItem.length) {
+                    this.flatten(nestedItem, out);
+                }
+            }
+        }
+
+        return out;
+    }
+}
+
+export default Visitor;

package/lib/less-browser/add-default-options.js

@@ -0,0 +1,49 @@
+import {addDataAttr} from './utils';
+import browser from './browser';
+
+export default (window, options) => {
+
+    // use options from the current script tag data attribues
+    addDataAttr(options, browser.currentScript(window));
+
+    if (options.isFileProtocol === undefined) {
+        options.isFileProtocol = /^(file|(chrome|safari)(-extension)?|resource|qrc|app):/.test(window.location.protocol);
+    }
+
+    // Load styles asynchronously (default: false)
+    //
+    // This is set to `false` by default, so that the body
+    // doesn't start loading before the stylesheets are parsed.
+    // Setting this to `true` can result in flickering.
+    //
+    options.async = options.async || false;
+    options.fileAsync = options.fileAsync || false;
+
+    // Interval between watch polls
+    options.poll = options.poll || (options.isFileProtocol ? 1000 : 1500);
+
+    options.env = options.env || (window.location.hostname == '127.0.0.1' ||
+        window.location.hostname == '0.0.0.0'   ||
+        window.location.hostname == 'localhost' ||
+        (window.location.port &&
+            window.location.port.length > 0)      ||
+        options.isFileProtocol                   ? 'development'
+        : 'production');
+
+    const dumpLineNumbers = /!dumpLineNumbers:(comments|mediaquery|all)/.exec(window.location.hash);
+    if (dumpLineNumbers) {
+        options.dumpLineNumbers = dumpLineNumbers[1];
+    }
+
+    if (options.useFileCache === undefined) {
+        options.useFileCache = true;
+    }
+
+    if (options.onReady === undefined) {
+        options.onReady = true;
+    }
+
+    if (options.relativeUrls) {
+        options.rewriteUrls = 'all';
+    }
+};

package/lib/less-browser/bootstrap.js

@@ -0,0 +1,69 @@
+/**
+ * Kicks off less and compiles any stylesheets
+ * used in the browser distributed version of less
+ * to kick-start less using the browser api
+ */
+/* global window, document */
+
+import defaultOptions from '../less/default-options';
+import addDefaultOptions from './add-default-options';
+import root from './index';
+
+const options = defaultOptions();
+
+if (window.less) {
+    for (const key in window.less) {
+        if (window.less.hasOwnProperty(key)) {
+            options[key] = window.less[key];
+        }
+    }
+}
+addDefaultOptions(window, options);
+
+options.plugins = options.plugins || [];
+
+if (window.LESS_PLUGINS) {
+    options.plugins = options.plugins.concat(window.LESS_PLUGINS);
+}
+
+const less = root(window, options);
+export default less;
+
+window.less = less;
+
+let css;
+let head;
+let style;
+
+// Always restore page visibility
+function resolveOrReject(data) {
+    if (data.filename) {
+        console.warn(data);
+    }
+    if (!options.async) {
+        head.removeChild(style);
+    }
+}
+
+if (options.onReady) {
+    if (/!watch/.test(window.location.hash)) {
+        less.watch();
+    }
+    // Simulate synchronous stylesheet loading by hiding page rendering
+    if (!options.async) {
+        css = 'body { display: none !important }';
+        head = document.head || document.getElementsByTagName('head')[0];
+        style = document.createElement('style');
+
+        style.type = 'text/css';
+        if (style.styleSheet) {
+            style.styleSheet.cssText = css;
+        } else {
+            style.appendChild(document.createTextNode(css));
+        }
+
+        head.appendChild(style);
+    }
+    less.registerStylesheetsImmediately();
+    less.pageLoadFinished = less.refresh(less.env === 'development').then(resolveOrReject, resolveOrReject);
+}

package/lib/less-browser/browser.js

@@ -0,0 +1,65 @@
+import * as utils from './utils';
+
+export default {
+    createCSS: function (document, styles, sheet) {
+        // Strip the query-string
+        const href = sheet.href || '';
+
+        // If there is no title set, use the filename, minus the extension
+        const id = `less:${sheet.title || utils.extractId(href)}`;
+
+        // If this has already been inserted into the DOM, we may need to replace it
+        const oldStyleNode = document.getElementById(id);
+        let keepOldStyleNode = false;
+
+        // Create a new stylesheet node for insertion or (if necessary) replacement
+        const styleNode = document.createElement('style');
+        styleNode.setAttribute('type', 'text/css');
+        if (sheet.media) {
+            styleNode.setAttribute('media', sheet.media);
+        }
+        styleNode.id = id;
+
+        if (!styleNode.styleSheet) {
+            styleNode.appendChild(document.createTextNode(styles));
+
+            // If new contents match contents of oldStyleNode, don't replace oldStyleNode
+            keepOldStyleNode = (oldStyleNode !== null && oldStyleNode.childNodes.length > 0 && styleNode.childNodes.length > 0 &&
+                oldStyleNode.firstChild.nodeValue === styleNode.firstChild.nodeValue);
+        }
+
+        const head = document.getElementsByTagName('head')[0];
+
+        // If there is no oldStyleNode, just append; otherwise, only append if we need
+        // to replace oldStyleNode with an updated stylesheet
+        if (oldStyleNode === null || keepOldStyleNode === false) {
+            const nextEl = sheet && sheet.nextSibling || null;
+            if (nextEl) {
+                nextEl.parentNode.insertBefore(styleNode, nextEl);
+            } else {
+                head.appendChild(styleNode);
+            }
+        }
+        if (oldStyleNode && keepOldStyleNode === false) {
+            oldStyleNode.parentNode.removeChild(oldStyleNode);
+        }
+
+        // For IE.
+        // This needs to happen *after* the style element is added to the DOM, otherwise IE 7 and 8 may crash.
+        // See http://social.msdn.microsoft.com/Forums/en-US/7e081b65-878a-4c22-8e68-c10d39c2ed32/internet-explorer-crashes-appending-style-element-to-head
+        if (styleNode.styleSheet) {
+            try {
+                styleNode.styleSheet.cssText = styles;
+            } catch (e) {
+                throw new Error('Couldn\'t reassign styleSheet.cssText.');
+            }
+        }
+    },
+    currentScript: function(window) {
+        const document = window.document;
+        return document.currentScript || (() => {
+            const scripts = document.getElementsByTagName('script');
+            return scripts[scripts.length - 1];
+        })();
+    }
+};

package/lib/less-browser/cache.js

@@ -0,0 +1,43 @@
+// Cache system is a bit outdated and could do with work
+
+export default (window, options, logger) => {
+    let 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) {
+            const css       = cache && cache.getItem(path);
+            const timestamp = cache && cache.getItem(`${path}:timestamp`);
+            let vars      = cache && cache.getItem(`${path}:vars`);
+
+            modifyVars = modifyVars || {};
+            vars = vars || "{}"; // if not set, treat as the JSON representation of an empty object
+
+            if (timestamp && webInfo.lastModified &&
+                (new Date(webInfo.lastModified).valueOf() ===
+                    new Date(timestamp).valueOf()) &&
+                JSON.stringify(modifyVars) === vars) {
+                // Use local copy
+                return css;
+            }
+        }
+    };
+};

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

@@ -0,0 +1,170 @@
+import * as utils from './utils';
+import browser from './browser';
+
+export default (window, less, options) => {
+
+    function errorHTML(e, rootHref) {
+        const id = `less-error-message:${utils.extractId(rootHref || '')}`;
+        const template = '<li><label>{line}</label><pre class="{class}">{content}</pre></li>';
+        const elem = window.document.createElement('div');
+        let timer;
+        let content;
+        const errors = [];
+        const filename = e.filename || rootHref;
+        const 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> `;
+
+        const errorline = (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.line) {
+            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(() => {
+                const document = window.document;
+                const 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) {
+        const 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) {
+        const template = '{line} {content}';
+        const filename = e.filename || rootHref;
+        const errors = [];
+        let content = `${e.type || 'Syntax'}Error: ${e.message || 'There is an error in your .less file'} in ${filename}`;
+
+        const errorline = (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.line) {
+            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
+    };
+};

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

@@ -0,0 +1,113 @@
+/* global window, XMLHttpRequest */
+
+import AbstractFileManager from '../less/environment/abstract-file-manager.js';
+
+let options;
+let logger;
+let fileCache = {};
+
+// TODOS - move log somewhere. pathDiff and doing something similar in node. use pathDiff in the other browser file for the initial load
+class FileManager extends AbstractFileManager {
+    alwaysMakePathsAbsolute() {
+        return true;
+    }
+
+    join(basePath, laterPath) {
+        if (!basePath) {
+            return laterPath;
+        }
+        return this.extractUrlParts(laterPath, basePath).path;
+    }
+
+    doXHR(url, type, callback, errback) {
+        const xhr = new XMLHttpRequest();
+        const 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 = () => {
+                if (xhr.readyState == 4) {
+                    handleResponse(xhr, callback, errback);
+                }
+            };
+        } else {
+            handleResponse(xhr, callback, errback);
+        }
+    }
+
+    supports() {
+        return true;
+    }
+
+    clearFileCache() {
+        fileCache = {};
+    }
+
+    loadFile(filename, currentDirectory, options, environment) {
+        // TODO: Add prefix support like less-node?
+        // What about multiple paths?
+
+        if (currentDirectory && !this.isPathAbsolute(filename)) {
+            filename = currentDirectory + filename;
+        }
+
+        filename = options.ext ? this.tryAppendExtension(filename, options.ext) : 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
+        const hrefParts = this.extractUrlParts(filename, window.location.href);
+        const href      = hrefParts.url;
+        const self      = this;
+        
+        return new Promise((resolve, reject) => {
+            if (options.useFileCache && fileCache[href]) {
+                try {
+                    const lessText = fileCache[href];
+                    return resolve({ contents: lessText, filename: href, webInfo: { lastModified: new Date() }});
+                } catch (e) {
+                    return reject({ filename: href, message: `Error loading file ${href} error was ${e.message}` });
+                }
+            }
+
+            self.doXHR(href, options.mime, function doXHRCallback(data, lastModified) {
+                // per file cache
+                fileCache[href] = data;
+
+                // Use remote copy (re-parse)
+                resolve({ contents: data, filename: href, webInfo: { lastModified }});
+            }, function doXHRError(status, url) {
+                reject({ type: 'File', message: `'${url}' wasn't found (${status})`, href });
+            });
+        });
+    }
+}
+
+export default (opts, log) => {
+    options = opts;
+    logger = log;
+    return FileManager;
+}