first commit

build/node_modules/css-tree/lib/generator/create.js

@@ -0,0 +1,161 @@
+'use strict';
+
+var sourceMapGenerator = require('./sourceMap');
+var hasOwnProperty = Object.prototype.hasOwnProperty;
+var noop = function() {};
+
+function each(processChunk, node) {
+    var list = node.children;
+    var cursor = list.head;
+
+    while (cursor !== null) {
+        this.generate(processChunk, cursor.data, cursor, list);
+        cursor = cursor.next;
+    }
+}
+
+function eachComma(processChunk, node) {
+    var list = node.children;
+    var cursor = list.head;
+
+    while (cursor !== null) {
+        if (cursor.prev) {
+            processChunk(',');
+        }
+
+        this.generate(processChunk, cursor.data, cursor, list);
+        cursor = cursor.next;
+    }
+}
+
+function createGenerator(types) {
+    var context = {
+        generate: function(processChunk, node, item, list) {
+            if (hasOwnProperty.call(types, node.type)) {
+                types[node.type].call(this, processChunk, node, item, list);
+            } else {
+                throw new Error('Unknown node type: ' + node.type);
+            }
+        },
+        each: each,
+        eachComma: eachComma
+    };
+
+    return function(node, fn) {
+        if (typeof fn !== 'function') {
+            // default generator concats all chunks in a single string
+            var buffer = [];
+            context.generate(function(chunk) {
+                buffer.push(chunk);
+            }, node);
+            return buffer.join('');
+        }
+        context.generate(fn, node);
+    };
+}
+
+function createMarkupGenerator(types) {
+    var context = {
+        generate: function(processChunk, node, item, list) {
+            if (hasOwnProperty.call(types, node.type)) {
+                var nodeBuffer = [];
+                types[node.type].call(this, function(chunk) {
+                    nodeBuffer.push(chunk);
+                }, node, item, list);
+                processChunk({
+                    node: node,
+                    value: nodeBuffer
+                });
+            } else {
+                throw new Error('Unknown node type: ' + node.type);
+            }
+        },
+        each: each,
+        eachComma: eachComma
+    };
+
+    return function(node, enter, leave) {
+        function updatePos(str) {
+            for (var i = 0; i < str.length; i++) {
+                if (str.charCodeAt(i) === 10) { // \n
+                    line++;
+                    column = 0;
+                } else {
+                    column++;
+                }
+            }
+
+            return str;
+        }
+
+        function walk(node, buffer) {
+            var value = node.value;
+
+            enter(node.node, buffer, line, column);
+
+            if (typeof value === 'string') {
+                buffer += updatePos(value);
+            } else {
+                for (var i = 0; i < value.length; i++) {
+                    if (typeof value[i] === 'string') {
+                        buffer += updatePos(value[i]);
+                    } else {
+                        buffer = walk(value[i], buffer);
+                    }
+                }
+            }
+
+            leave(node.node, buffer, line, column);
+
+            return buffer;
+        }
+
+        if (typeof enter !== 'function') {
+            enter = noop;
+        }
+        if (typeof leave !== 'function') {
+            leave = noop;
+        }
+
+        var buffer = [];
+        var line = 1;
+        var column = 0;
+
+        context.generate(function() {
+            buffer.push.apply(buffer, arguments);
+        }, node);
+
+        return walk(buffer[0], '');
+    };
+}
+
+function getTypesFromConfig(config) {
+    var types = {};
+
+    if (config.node) {
+        for (var name in config.node) {
+            var nodeType = config.node[name];
+
+            types[name] = nodeType.generate;
+        }
+    }
+
+    return types;
+}
+
+module.exports = function(config) {
+    var types = getTypesFromConfig(config);
+    var markupGenerator = createMarkupGenerator(types);
+
+    return {
+        translate: createGenerator(types),
+        translateWithSourceMap: function(node) {
+            return sourceMapGenerator(markupGenerator, node);
+        },
+        translateMarkup: markupGenerator
+    };
+};
+
+module.exports.createGenerator = createGenerator;
+module.exports.createMarkupGenerator = createMarkupGenerator;
+module.exports.sourceMap = require('./sourceMap');