Remove babel-polyfill

.gitignore

@@ -1,3 +1,2 @@
-dist
 node_modules
 coverage

dist/formats/deps.js/index.js

@@ -0,0 +1,17 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _reader = require('./reader');
+
+var _reader2 = _interopRequireDefault(_reader);
+
+var _parser = require('./parser');
+
+var _parser2 = _interopRequireDefault(_parser);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+exports.default = { parser: _parser2.default, reader: _reader2.default };

dist/formats/deps.js/normalize.js

@@ -0,0 +1,137 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+
+var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol ? "symbol" : typeof obj; };
+
+exports.default = function (deps, options) {
+    if (!deps) {
+        return [];
+    }
+    if (!Array.isArray(deps)) {
+        deps = [deps];
+    }
+
+    return deps.reduce(function (previous, current) {
+        return previous.concat(normalize(current, options));
+    }, []);
+};
+
+var props = ['block', 'elem', 'modName', 'modVal', 'tech'];
+
+function extend(target, source) {
+    for (var i = 0; i < props.length; i++) {
+        var prop = props[i];
+        if (target[prop]) {
+            continue;
+        }
+        if (source[prop]) {
+            target[prop] = source[prop];
+        }
+    }
+    return target;
+}
+
+function defaultParseString(dep) {
+    return [{ block: dep }];
+}
+
+function normalize(dep, options) {
+    var res = [];
+
+    options = options || {};
+    options.parseString = options.parseString || defaultParseString;
+
+    if (typeof dep === 'string' && options.parseString) {
+        return options.parseString(dep);
+    }
+
+    if (Object.keys(dep).length === 0) {
+        throw new Error(dep + ' is empty deps object');
+    }
+
+    if (typeof dep.elems === 'string' || _typeof(dep.elems) === 'object' && !Array.isArray(dep.elems)) {
+        dep.elems = [dep.elems];
+    }
+
+    if (dep.elem !== undefined && dep.elems !== undefined) {
+        throw new Error('Cannot have `elem` and `elems` in its dependencies');
+    }
+
+    if (dep.mod !== undefined) {
+        dep.modName = dep.mod;
+        delete dep.mod;
+    }
+
+    if (dep.val !== undefined) {
+        dep.modVal = dep.val;
+        delete dep.val;
+    }
+
+    if (dep.modName !== undefined && dep.mods !== undefined) {
+        throw new Error('Cannot have `mod` and `mods` in dependencies');
+    }
+
+    if (Array.isArray(dep.elem)) {
+        dep.elems = dep.elem;
+        delete dep.elem;
+    }
+
+    if (dep.elems) {
+        res.push({ block: dep.block });
+
+        dep.elems.forEach(function (elem, idx) {
+            if (elem === '') return;
+
+            if (!elem.elem) return res.push(extend({ elem: elem }, dep));
+
+            // processing such cases:
+            // {
+            //     block: 'b1',
+            //     elem: [
+            //         'e1',
+            //         {
+            //             elem: 'e2',
+            //             mods: { m1: 'v1' }
+            //         }
+            //     ]
+            // }
+            normalize(elem).forEach(function (e) {
+                res.push(extend({ elem: e }, dep));
+            });
+        });
+    }
+
+    if (dep.mods) {
+        res.push({ block: dep.block });
+
+        if (Array.isArray(dep.mods)) {
+            dep.mods.forEach(function (mod) {
+                if (mod === '') return;
+
+                res.push(extend({ modName: mod }, dep));
+            });
+        } else {
+            Object.keys(dep.mods).forEach(function (mod) {
+                if (!Array.isArray(dep.mods[mod])) {
+                    dep.mods[mod] = [dep.mods[mod]];
+                }
+
+                res.push(extend({ modName: mod, modVal: true }, dep));
+                dep.mods[mod].forEach(function (value) {
+                    value !== true && res.push(extend({ modName: mod, modVal: value }, dep));
+                });
+            });
+        }
+    }
+
+    if (!dep.elems && !dep.mods) {
+        res.push(dep);
+    }
+
+    return res;
+}
+
+;

dist/formats/deps.js/parser.js

@@ -0,0 +1,81 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+exports.default = parser;
+
+var _lodash = require('lodash');
+
+var _lodash2 = _interopRequireDefault(_lodash);
+
+var _bemNaming = require('bem-naming');
+
+var _bemNaming2 = _interopRequireDefault(_bemNaming);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function parser(entityDeps) {
+    var result = {
+        entity: entityDeps.entity,
+        dependOn: []
+    };
+
+    function normalize(deps) {
+        if (typeof deps === 'string') {
+            deps = { block: deps };
+        }
+
+        if (!Array.isArray(deps)) {
+            deps = [deps];
+        }
+
+        return deps;
+    }
+
+    function add(mustOrShouldDeps, isMust) {
+        if (!mustOrShouldDeps) return;
+
+        normalize(mustOrShouldDeps).forEach(function (dep) {
+            var dependOnEntity = {
+                block: dep.block
+            };
+
+            ['elem', 'modName', 'modVal'].forEach(function (field) {
+                dep[field] && (dependOnEntity[field] = dep[field]);
+            });
+
+            var dependency = {
+                entity: dependOnEntity,
+                tech: dep.tech
+            };
+
+            isMust && (dependency.order = 'dependenceBeforeDependants');
+
+            _lodash2.default.some(result.dependOn, dependency) || result.dependOn.push(dependency);
+        });
+    }
+
+    function remove(noDeps) {
+        noDeps.forEach(function (noDep) {
+            result.dependOn.forEach(function (dep, idx) {
+                if (_bemNaming2.default.stringify(dep.entity) + dep.tech === _bemNaming2.default.stringify(noDep) + noDep.tech) {
+                    result.dependOn.splice(idx, 1);
+                }
+            });
+        });
+    }
+
+    // `entityDeps.deps` is an array of all entity dependencies from all files
+    entityDeps.deps.forEach(function (entityOneFileDeps) {
+        entityOneFileDeps.forEach(function (oneTechDeps) {
+            oneTechDeps.tech && (result.tech = oneTechDeps.tech);
+
+            add(oneTechDeps.mustDeps, true);
+            add(oneTechDeps.shouldDeps);
+            remove(oneTechDeps.noDeps);
+        });
+    });
+
+    return result;
+};

dist/formats/deps.js/reader.js

@@ -0,0 +1,47 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+exports.default = reader;
+
+var _fs = require('fs');
+
+var _fs2 = _interopRequireDefault(_fs);
+
+var _normalize = require('./normalize');
+
+var _normalize2 = _interopRequireDefault(_normalize);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+/**
+ * Reads file and calls callback with normalized dependency object
+ * @param {Object}
+ */
+function reader(file, cb) {
+    _fs2.default.readFile(file.path, function (err, depsText) {
+        if (err) return cb(err);
+
+        var parsedDeps = eval(depsText.toString());
+
+        Array.isArray(parsedDeps) || (parsedDeps = [parsedDeps]);
+
+        cb(null, parsedDeps.map(function (dep) {
+            ['mustDeps', 'shouldDeps', 'noDeps'].forEach(function (depsType) {
+                dep[depsType] = (0, _normalize2.default)(dep[depsType]);
+
+                dep[depsType].forEach(function (entity) {
+                    entity.block || (entity.block = file.entity.block);
+                    entity.elem || (entity.elem = file.entity.elem);
+                });
+            });
+
+            ['block', 'elem', 'modName', 'modVal'].forEach(function (field) {
+                if (!dep[field] && file.entity[field]) dep[field] = file.entity[field];
+            });
+
+            return dep;
+        }));
+    });
+};

dist/index.js

@@ -0,0 +1,29 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.resolve = exports.parse = exports.read = exports.load = undefined;
+
+var _read = require('./read');
+
+var _read2 = _interopRequireDefault(_read);
+
+var _parse = require('./parse');
+
+var _parse2 = _interopRequireDefault(_parse);
+
+var _load = require('./load');
+
+var _load2 = _interopRequireDefault(_load);
+
+var _resolve = require('./resolve');
+
+var _resolve2 = _interopRequireDefault(_resolve);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+exports.load = _load2.default;
+exports.read = _read2.default;
+exports.parse = _parse2.default;
+exports.resolve = _resolve2.default;

dist/load.js

@@ -0,0 +1,27 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+
+exports.default = function (config) {
+    var format = arguments.length <= 1 || arguments[1] === undefined ? _deps2.default : arguments[1];
+
+    return (0, _read2.default)(config, format.reader).pipe((0, _parse2.default)(format.parser));
+};
+
+var _read = require('./read');
+
+var _read2 = _interopRequireDefault(_read);
+
+var _parse = require('./parse');
+
+var _parse2 = _interopRequireDefault(_parse);
+
+var _deps = require('./formats/deps.js');
+
+var _deps2 = _interopRequireDefault(_deps);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+;

dist/parse.js

@@ -0,0 +1,29 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+exports.default = parse;
+
+var _stream = require('stream');
+
+var _stream2 = _interopRequireDefault(_stream);
+
+var _parser = require('./formats/deps.js/parser');
+
+var _parser2 = _interopRequireDefault(_parser);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function parse() {
+    var parser = arguments.length <= 0 || arguments[0] === undefined ? _parser2.default : arguments[0];
+
+    var transform = new _stream2.default.Transform({ objectMode: true });
+
+    transform._transform = function (entityDeps, encoding, done) {
+        this.push(parser(entityDeps));
+        done();
+    };
+
+    return transform;
+};