@git-temporal/git-temporal-react/lib/app/selectors/files.js

<!-- START doctoc generated TOC please keep comment here to allow auto update --> <!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE -->

"use strict";
var __importStar = (this && this.__importStar) || function (mod) {
    if (mod && mod.__esModule) return mod;
    var result = {};
    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
    result["default"] = mod;
    return result;
};
Object.defineProperty(exports, "__esModule", { value: true });
const path = __importStar(require("path"));
const reselect_1 = require("reselect");
const ActionTypes_1 = require("app/actions/ActionTypes");
const stateVars_1 = require("./stateVars");
const search_1 = require("./search");
const commits_1 = require("./commits");
const getObjectValues = function (obj) {
    const values = [];
    for (const key in obj) {
        values.push(obj[key]);
    }
    return values;
};
exports.getFilteredFiles = reselect_1.createSelector(commits_1.getFilteredCommits, stateVars_1.getFilesContainerSort, stateVars_1.getSearch, (commits, filesContainerSort) => {
    const commitsByFile = {};
    for (const commit of commits) {
        if (!commit.files) {
            continue;
        }
        for (const file of commit.files) {
            const thisFile = commitsByFile[file.name] || {
                fileName: file.name,
                authorNames: [],
                commits: [],
                linesAdded: 0,
                linesDeleted: 0,
                firstCommitOn: commit.authorDate,
                lastCommitOn: commit.authorDate,
            };
            if (thisFile.authorNames.indexOf(commit.authorName) === -1) {
                thisFile.authorNames.push(commit.authorName);
            }
            if (commit.authorDate < thisFile.firstCommitOn) {
                thisFile.firstCommitOn = commit.authorDate;
            }
            if (commit.authorDate > thisFile.lastCommitOn) {
                thisFile.lastCommitOn = commit.authorDate;
            }
            thisFile.linesAdded += file.linesAdded;
            thisFile.linesDeleted += file.linesDeleted;
            thisFile.commits.push(commit);
            commitsByFile[file.name] = thisFile;
        }
    }
    const filteredFiles = getObjectValues(commitsByFile);
    return filteredFiles.sort((a, b) => {
        switch (filesContainerSort) {
            case ActionTypes_1.FilesContainerSorts.LINES:
                return (b.linesAdded + b.linesDeleted - (a.linesAdded + a.linesDeleted));
            case ActionTypes_1.FilesContainerSorts.TIME:
                return b.lastCommitOn - a.lastCommitOn;
            case ActionTypes_1.FilesContainerSorts.COMMITS:
                return b.commits.length - a.commits.length;
        }
        return 0;
    });
});
exports.getFilteredFilesForFilesContainer = reselect_1.createSelector(exports.getFilteredFiles, stateVars_1.getSearch, (files, search) => {
    if (search_1.hasSearch(search) && search.match(search_1.fileSearchRegex)) {
        return files.filter(file => {
            return search_1.matchesFileSearch(file.fileName, search);
        });
    }
    return files;
});
exports.getDirectoryDiff = reselect_1.createSelector(stateVars_1.getDiff, (diff) => {
    if (!diff || !diff.isDirectory) {
        return null;
    }
    const leftTree = {};
    const rightTree = {};
    if (!diff.modifiedFiles) {
        return {};
    }
    let index = 0;
    diff.modifiedFiles.forEach(file => {
        let trees = [];
        switch (file.status) {
            case 'added':
                trees = [rightTree];
                break;
            case 'deleted':
                trees = [leftTree];
                break;
            case 'modified':
                trees = [leftTree, rightTree];
                break;
        }
        for (const tree of trees) {
            let currentNode = tree;
            const parsedPaths = file.path.split(path.sep);
            parsedPaths.forEach((pathPart, pathPartIndex) => {
                let nodeForPart = currentNode[pathPart];
                if (!nodeForPart) {
                    nodeForPart = currentNode[pathPart] = {
                        index,
                        status: file.status,
                        delta: file.delta,
                        fullPath: parsedPaths.slice(0, pathPartIndex + 1).join(path.sep),
                        nodes: {},
                    };
                    index += 1;
                }
                else {
                    nodeForPart.status =
                        file.status === 'modified' ? 'modified' : nodeForPart.status;
                    nodeForPart.delta = nodeForPart.delta + file.delta;
                }
                currentNode = nodeForPart.nodes;
            });
        }
    });
    return {
        leftTree,
        rightTree,
    };
});