@essex/redux-dag-history/lib/DagGraph.js

"use strict";
var immutable_1 = require("immutable");
var log = require('debug')('redux-dag-history:DagGraph');
var treeify = require('treeify');
var DagGraph = (function () {
    function DagGraph(graph) {
        this.graph = graph;
        if (!graph) {
            throw new Error('\'graph\' parameter must be defined');
        }
        if (!graph.getIn) {
            throw new Error('\'graph\' must be an immutablejs instance');
        }
    }
    DagGraph.prototype.print = function () {
        var _this = this;
        var graph = this.graph.toJS();
        var root = null;
        var states = {};
        var getOrCreateState = function (stateId) {
            var result = states[stateId];
            if (!result) {
                result = {
                    id: stateId,
                    name: _this.stateName(stateId),
                    children: [],
                };
                states[stateId] = result;
            }
            return result;
        };
        Object.keys(graph.states || {}).forEach(function (stateId) {
            var parentId = graph.states[stateId].parent;
            var state = getOrCreateState(stateId);
            if (!parentId) {
                root = state;
            }
            getOrCreateState(parentId).children.push(state);
            states[stateId] = state;
        });
        var tree = {
            current: graph.current,
            branches: graph.branches,
            dag: root,
        };
        var result = treeify.asTree(tree, true);
        return result;
    };
    Object.defineProperty(DagGraph.prototype, "currentStateId", {
        get: function () {
            return this.graph.getIn(['current', 'state']);
        },
        enumerable: true,
        configurable: true
    });
    DagGraph.prototype.branchStartDepth = function (branch) {
        return this.stateDepth(this.firstOn(branch));
    };
    DagGraph.prototype.branchEndDepth = function (branch) {
        return this.stateDepth(this.latestOn(branch));
    };
    DagGraph.prototype.stateDepth = function (commit) {
        return this.commitPath(commit).length - 1;
    };
    DagGraph.prototype.depthIndexOf = function (branch, commit) {
        var commits = this.branchCommitPath(branch);
        var foundIndex = commits.indexOf(commit);
        if (foundIndex === -1) {
            return undefined;
        }
        else {
            var start = this.branchStartDepth(branch);
            return start + foundIndex;
        }
    };
    Object.defineProperty(DagGraph.prototype, "maxDepth", {
        get: function () {
            var _this = this;
            var branches = this.branches;
            var branchDepths = branches.map(function (b) { return _this.branchEndDepth(b); });
            var max = -1;
            branchDepths.forEach(function (d) {
                if (d > max) {
                    max = d;
                }
            });
            return max;
        },
        enumerable: true,
        configurable: true
    });
    DagGraph.prototype.setCurrentStateId = function (stateId) {
        this.graph = this.graph.setIn(['current', 'state'], stateId);
        return this;
    };
    Object.defineProperty(DagGraph.prototype, "currentBranch", {
        get: function () {
            return this.graph.getIn(['current', 'branch']);
        },
        enumerable: true,
        configurable: true
    });
    DagGraph.prototype.setCurrentBranch = function (branchId) {
        this.graph = this.graph.setIn(['current', 'branch'], branchId);
        return this;
    };
    DagGraph.prototype.latestOn = function (branch) {
        return this.graph.getIn(['branches', "" + branch, 'latest']);
    };
    DagGraph.prototype.committedOn = function (branch) {
        return this.graph.getIn(['branches', "" + branch, 'committed']);
    };
    DagGraph.prototype.setLatest = function (branch, commit) {
        this.graph = this.graph.setIn(['branches', "" + branch, 'latest'], commit);
        return this;
    };
    DagGraph.prototype.setCommitted = function (branch, commit) {
        this.graph = this.graph.setIn(['branches', "" + branch, 'committed'], commit);
        return this;
    };
    DagGraph.prototype.markStateForBranch = function (commit, branch) {
        this.graph = this.graph.setIn(['states', "" + commit, 'branch'], branch);
        return this;
    };
    DagGraph.prototype.setFirst = function (branch, commit) {
        this.graph = this.graph.setIn(['branches', "" + branch, 'first'], commit);
        return this;
    };
    DagGraph.prototype.firstOn = function (branch) {
        return this.graph.getIn(['branches', "" + branch, 'first']);
    };
    DagGraph.prototype.renameState = function (commit, name) {
        this.graph = this.graph.setIn(['states', "" + commit, 'name'], name);
        return this;
    };
    DagGraph.prototype.stateName = function (commit) {
        return this.graph.getIn(['states', "" + commit, 'name']);
    };
    DagGraph.prototype.getBranchName = function (branch) {
        return this.graph.getIn(['branches', "" + branch, 'name']);
    };
    DagGraph.prototype.setBranchName = function (branch, name) {
        this.graph = this.graph.setIn(['branches', "" + branch, 'name'], name);
        return this;
    };
    DagGraph.prototype.getState = function (commit) {
        return this.graph.getIn(['states', "" + commit, 'state']);
    };
    DagGraph.prototype.insertState = function (commit, parent, state, name) {
        log('Inserting new commit', commit);
        var newState = immutable_1.fromJS({
            name: name,
            parent: parent,
        }).set('state', state);
        if (this.graph.getIn(['states', "" + commit])) {
            log('Commit %s is already present', this.getState(commit));
        }
        this.graph = this.graph.setIn(['states', "" + commit], newState);
        return this;
    };
    DagGraph.prototype.childrenOf = function (commit) {
        var states = this.graph.get('states');
        return states.toSeq()
            .filter(function (state) { return state.get('parent') === commit; })
            .map(function (state, key) { return key; })
            .toList().toJS();
    };
    DagGraph.prototype.parentOf = function (commit) {
        return this.graph.getIn(['states', "" + commit, 'parent']);
    };
    DagGraph.prototype.alternateParentsOf = function (commit) {
        var result = this.graph.getIn(['states', "" + commit, 'alternateParents']);
        return result ? result.toJS() : [];
    };
    DagGraph.prototype.shallowestParentOf = function (commit) {
        var _this = this;
        var allParents = [
            this.parentOf(commit)
        ].concat(this.alternateParentsOf(commit));
        var result = undefined;
        var minDepth = undefined;
        allParents.forEach(function (t) {
            var depth = _this.depthIndexOf(_this.branchOf(t), t);
            if (minDepth === undefined || depth < minDepth) {
                minDepth = depth;
                result = t;
            }
        });
        return result;
    };
    DagGraph.prototype.replaceState = function (commit, state) {
        this.graph = this.graph.setIn(['states', "" + commit, 'state'], state);
        return this;
    };
    DagGraph.prototype.commitPath = function (commit) {
        if (commit === undefined) {
            return [];
        }
        var path = [commit];
        var current = commit;
        do {
            var parent_1 = this.parentOf(current);
            if (parent_1) {
                path.unshift(parent_1);
            }
            current = parent_1;
        } while (current);
        return path;
    };
    DagGraph.prototype.shortestCommitPath = function (commit) {
        if (commit === undefined) {
            return [];
        }
        var path = [commit];
        var current = commit;
        do {
            var parent_2 = this.shallowestParentOf(current);
            if (parent_2) {
                path.unshift(parent_2);
            }
            current = parent_2;
        } while (current);
        return path;
    };
    DagGraph.prototype.branchCommitPath = function (branch) {
        if (branch === undefined) {
            return [];
        }
        var latest = this.latestOn(branch);
        var path = this.commitPath(latest);
        var firstCommitOnBranch = this.firstOn(branch);
        return path.slice(path.indexOf(firstCommitOnBranch));
    };
    DagGraph.prototype.setParent = function (commit, parent) {
        this.graph = this.graph.setIn(['states', "" + commit, 'parent'], parent);
    };
    DagGraph.prototype.setAlternateParent = function (commit, parent) {
        if (this.parentOf(commit) !== parent) {
            return;
        }
        var path = ['states', "" + commit, 'alternateParents'];
        var parentList = this.graph.getIn(path) ||
            immutable_1.List();
        if (!parentList.contains(parent)) {
            this.graph = this.graph.setIn(path, parentList.push(parent));
        }
    };
    Object.defineProperty(DagGraph.prototype, "branches", {
        get: function () {
            var branches = this.graph.get('branches');
            return Array.from(branches.keys());
        },
        enumerable: true,
        configurable: true
    });
    DagGraph.prototype.branchOf = function (commit) {
        return this.graph.getIn(['states', "" + commit, 'branch']);
    };
    DagGraph.prototype.branchesOf = function (commit) {
        var _this = this;
        if (!commit) {
            throw new Error('commit must be defined');
        }
        var children = this.childrenOf(commit);
        if (children.length === 0) {
            var branches = [];
            for (var _i = 0, _a = this.branches; _i < _a.length; _i++) {
                var branch = _a[_i];
                if (this.latestOn(branch) === commit) {
                    branches.push(branch);
                }
            }
            return branches;
        }
        else {
            var result_1 = [];
            var childrenBranches = children.map(function (child) { return _this.branchesOf(child); });
            childrenBranches.forEach(function (cb) { return result_1 = result_1.concat.apply(result_1, cb); });
            return result_1;
        }
    };
    DagGraph.prototype.remove = function (commit) {
        this.graph = this.graph.deleteIn(['states', "" + commit]);
    };
    DagGraph.prototype.squashCurrentBranch = function () {
        var _this = this;
        var toSquash = [];
        var branch = this.branchOf(this.currentStateId);
        var current = this.parentOf(this.currentStateId);
        var keepSquashing = true;
        do {
            if (current && this.branchOf(current) === branch) {
                toSquash.push(current);
                current = this.parentOf(current);
            }
            else {
                keepSquashing = false;
            }
        } while (keepSquashing);
        log('squashing %s states on branch %s => ', toSquash.length, branch, current, toSquash);
        if (toSquash.length > 0) {
            toSquash.forEach(function (c) { return _this.remove(c); });
            this.setParent(this.currentStateId, current);
        }
        return this;
    };
    return DagGraph;
}());
Object.defineProperty(exports, "__esModule", { value: true });
exports.default = DagGraph;