tortilla/dist/package.js

"use strict";
var __assign = (this && this.__assign) || function () {
    __assign = Object.assign || function(t) {
        for (var s, i = 1, n = arguments.length; i < n; i++) {
            s = arguments[i];
            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
                t[p] = s[p];
        }
        return t;
    };
    return __assign.apply(this, arguments);
};
Object.defineProperty(exports, "__esModule", { value: true });
var Fs = require("fs-extra");
var git_1 = require("./git");
var local_storage_1 = require("./local-storage");
var manual_1 = require("./manual");
var paths_1 = require("./paths");
var step_1 = require("./step");
var utils_1 = require("./utils");
/**
 This module contains package.json related methods
 */
// Updates all the dependencies in the package.json file based on a provided manifest.
// If no manifest was provided an editor will be provided where we will be able to create
// the manifest on the run. Rebase conflicts will be resolved automatically
function updateDependencies(updatedDeps) {
    if (updatedDeps) {
        if (!(updatedDeps instanceof Object)) {
            throw TypeError('New dependencies must be described using an object');
        }
    }
    else {
        var pack = Fs.readJsonSync(paths_1.Paths.npm.package);
        var deps_1 = __assign({}, pack.dependencies, pack.devDependencies, pack.peerDependencies);
        var versionColumn_1 = Object.keys(deps_1).reduce(function (depLength, dep) {
            return depLength < dep.length ? dep.length : depLength;
        }, 0);
        var initialContent = '# Please pick the new versions of the project\'s dependencies\n\n';
        initialContent += Object.keys(deps_1).sort().map(function (dep) {
            return utils_1.Utils.padRight(dep, versionColumn_1) + " " + deps_1[dep];
        }).join('\n');
        var editedContent = git_1.Git.edit(initialContent);
        if (initialContent === editedContent) {
            return;
        }
        updatedDeps = editedContent
            .trim()
            .replace(/# .+/g, '')
            .split('\n')
            .map(function (line) { return line.trim(); })
            .filter(Boolean)
            .map(function (line) { return line.split(/\s+/); })
            .reduce(function (prev, _a) {
            var dep = _a[0], version = _a[1];
            prev[dep] = version;
            return prev;
        }, {});
    }
    var packSteps = git_1.Git([
        'log',
        '--format=%s',
        '--grep=^Step [0-9]\\+',
        '--',
        paths_1.Paths.npm.package,
    ]).split('\n')
        .filter(Boolean)
        .map(function (line) { return step_1.Step.descriptor(line).number; });
    var minPackSuperStep = Math.min.apply(Math, packSteps).toFixed();
    var missingSuperSteps = git_1.Git([
        'log',
        '--format=%s',
        '--grep=^Step [0-9]\\+:',
    ]).split('\n')
        .filter(Boolean)
        .map(function (line) { return step_1.Step.descriptor(line).number.toString(); })
        .filter(function (step) { return !packSteps.includes(step); })
        .filter(function (step) { return step >= minPackSuperStep; });
    var steps = []
        .concat(packSteps)
        .concat(missingSuperSteps);
    // Checking if the root commit has affected the package.json, since it has been
    // filtered in the last operation
    var shouldEditRoot = git_1.Git([
        'diff-tree', '--no-commit-id', '--name-only', '-r', git_1.Git.rootHash(),
    ]).includes('package.json');
    if (shouldEditRoot) {
        steps.push('root');
    }
    step_1.Step.edit(steps);
    var rebaseHooksDisabled;
    try {
        rebaseHooksDisabled = local_storage_1.localStorage.getItem('REBASE_HOOKS_DISABLED');
    }
    catch (e) {
        rebaseHooksDisabled = '';
    }
    try {
        // We completely trust Tortilla to do its thing right now and we don't need any
        // modifications to the commit messages
        local_storage_1.localStorage.setItem('REBASE_HOOKS_DISABLED', 1);
        var _loop_1 = function () {
            // Reading package.json content and ensuring it's formatted correctly
            var packContent = Fs.readFileSync(paths_1.Paths.npm.package).toString();
            // Plucking indention
            var indent = packContent.match(/\{\n([^"]+)/) || [];
            // Default indention
            indent = indent[1] || '\s\s';
            var currPackContent = void 0;
            var headPackContent = currPackContent = packContent;
            // Keep replacing conflict notations until we get both unresolved versions
            for (var newHeadPackContent = void 0, newCurrPackContent = void 0; newHeadPackContent !== headPackContent &&
                newCurrPackContent !== currPackContent; newHeadPackContent = headPackContent.replace(git_1.Git.conflict, '$1'),
                newCurrPackContent = currPackContent.replace(git_1.Git.conflict, '$2')) {
                // Force initialization
                if (!newHeadPackContent || !newCurrPackContent) {
                    continue;
                }
                headPackContent = newHeadPackContent;
                currPackContent = newCurrPackContent;
            }
            var headPack = JSON.parse(headPackContent);
            var currPack = JSON.parse(currPackContent);
            var depsTypes = ['dependencies', 'devDependencies', 'peerDependencies'];
            // We have some conflicts to resolve
            if (headPackContent !== currPackContent) {
                // Picking the updated dependencies versions
                depsTypes.forEach(function (depsType) {
                    if (!currPack[depsType] || !headPack[depsType]) {
                        return;
                    }
                    Object.keys(headPack[depsType]).forEach(function (dep) {
                        if (currPack[depsType][dep]) {
                            currPack[depsType][dep] = headPack[depsType][dep];
                        }
                    });
                });
            }
            // Running a second update based on the provided manifest
            Object.keys(updatedDeps).forEach(function (dep) {
                // Picking the updated dependencies versions
                depsTypes.forEach(function (depsType) {
                    if (!currPack[depsType]) {
                        return;
                    }
                    Object.keys(updatedDeps).forEach(function (dependencyName) {
                        if (currPack[depsType][dependencyName]) {
                            currPack[depsType][dependencyName] = updatedDeps[dependencyName];
                        }
                    });
                });
            });
            Fs.writeFileSync(paths_1.Paths.npm.package, JSON.stringify(currPack, null, indent));
            git_1.Git.print(['add', paths_1.Paths.npm.package]);
            // If this is root commit or a super-step, re-render the correlated manual
            var commitMsg = git_1.Git.recentCommit(['--format=%s']);
            var isSuperStep = !!step_1.Step.superDescriptor(commitMsg);
            // If there are staged files, it's probably a conflict in the following step in
            // we're not really in a super step
            if (isSuperStep && !git_1.Git.stagedFiles().length) {
                manual_1.Manual.render();
            }
            try {
                git_1.Git.print(['rebase', '--continue'], { env: { GIT_EDITOR: true } });
            }
            catch (e) {
                var modifiedFiles = git_1.Git(['diff', '--name-only'])
                    .split('\n')
                    .filter(Boolean);
                // Checking if only package.json is both modified
                var expectedConflict = modifiedFiles.length === 2 && modifiedFiles.every(function (file) {
                    return file === 'package.json';
                });
                if (!expectedConflict) {
                    throw e;
                }
            }
        };
        while (git_1.Git.rebasing()) {
            _loop_1();
        }
    }
    finally {
        // Resume editing commit messages
        if (rebaseHooksDisabled) {
            local_storage_1.localStorage.setItem('REBASE_HOOKS_DISABLED', rebaseHooksDisabled);
        }
        else {
            local_storage_1.localStorage.removeItem('REBASE_HOOKS_DISABLED');
        }
    }
}
exports.Package = {
    updateDependencies: updateDependencies,
};
//# sourceMappingURL=package.js.map