BE-SPAN/node_modules/toposort-class/toposort.js

!function() {
    "use strict";

    /**
     * Topological sort class.
     * Original by Marcel Klehr, contributed by Gustavo Henke.
     *
     * @class
     * @since   0.1.0
     * @see     https://github.com/marcelklehr/toposort
     * @author  Marcel Klehr <mklehr@gmx.net>
     *
     * @see     https://github.com/gustavohenke/toposort
     * @author  Gustavo Henke <gustavo@injoin.com.br>
     */
    function Toposort() {
        var self = this;
        var edges = [];

        /**
         * Adds dependency edges.
         *
         * @since   0.1.0
         * @param   {String} item               An dependent name. Must be an string and not empty
         * @param   {String[]|String} [deps]    An dependency or array of dependencies
         * @returns {Toposort}                  The Toposort instance
         */
        self.add = function( item, deps ) {
            if ( typeof item !== "string" || !item ) {
                throw new TypeError( "Dependent name must be given as a not empty string" );
            }

            deps = Array.isArray( deps ) ? deps.slice() : [ deps ];
            if ( deps.length ) {
                deps.forEach(function( dep ) {
                    if ( typeof dep !== "string" || !dep ) {
                        throw new TypeError(
                            "Dependency name must be given as a not empty string"
                        );
                    }

                    edges.push([ item, dep ]);
                });
            } else {
                edges.push([ item ]);
            }

            return self;
        };

        /**
         * Runs the toposorting and return an ordered array of strings
         *
         * @since   0.1.0
         * @returns {String[]}  The list of items topologically sorted.
         */
        self.sort = function() {
            var nodes = [];
            var sorted = [];

            edges.forEach(function( edge ) {
                edge.forEach(function( n ) {
                    if ( nodes.indexOf( n ) === -1 ) {
                        nodes.push( n );
                    }
                });
            });

            function visit( node, predecessors, i ) {
                var index, predsCopy;
                predecessors = predecessors || [];

                if ( predecessors.indexOf( node ) > -1 ) {
                    throw new Error(
                        "Cyclic dependency found. '" + node + "' is dependent of itself.\n" +
                        "Dependency Chain: " + predecessors.join( " -> " ) + " => " + node
                    );
                }

                index = nodes.indexOf( node );
                if ( index === -1 ) {
                    return i;
                }

                nodes.splice( index, 1 );
                if ( predecessors.length === 0 ) {
                    i--;
                }

                predsCopy = predecessors.slice();
                predsCopy.push( node );

                edges.filter(function( e ) {
                    return e[ 0 ] === node;
                }).forEach(function( e ) {
                    i = visit( e[ 1 ], predsCopy, i );
                });

                sorted.unshift( node );
                return i;
            }

            for ( var i = 0; i < nodes.length; i++ ) {
                i = visit( nodes[ i ], null, i );
            }

            return sorted;
        };

    }

    if ( typeof module === "object" && module && typeof module.exports === "object" ) {
        // Expose toposort to CommonJS loaders (aka Node)
        module.exports = exports.Toposort = Toposort;
    } else {
        // Expose toposort to AMD loaders (aka Require.js)
        if ( typeof define === "function" && define.amd ) {
            define(function() {
                return Toposort;
            });
        }

        // Expose toposort as a browser global
        if ( typeof window === "object" ) {
            window.Toposort = Toposort;
        }
    }
}();