electron-complete-builder/out/packager.js

"use strict";
const fs = require("fs");
const path = require("path");
const util_1 = require("./util");
const promisifed_fs_1 = require("./promisifed-fs");
const promise_1 = require("./promise");
const events_1 = require("events");
const bluebird_1 = require("bluebird");
const awaiter_1 = require("./awaiter");
const __awaiter = awaiter_1.tsAwaiter;
Array.isArray(__awaiter);
function addHandler(emitter, event, handler) {
    emitter.on(event, handler);
}
class Packager {
    constructor(options, repositoryInfo = null) {
        this.options = options;
        this.repositoryInfo = repositoryInfo;
        this.isTwoPackageJsonProjectLayoutUsed = true;
        this.eventEmitter = new events_1.EventEmitter();
        this.projectDir = options.projectDir == null ? process.cwd() : path.resolve(options.projectDir);
        this.appDir = this.computeAppDirectory();
    }
    artifactCreated(handler) {
        addHandler(this.eventEmitter, "artifactCreated", handler);
        return this;
    }
    get devPackageFile() {
        return path.join(this.projectDir, "package.json");
    }
    build() {
        return __awaiter(this, void 0, void 0, function* () {
            const buildPackageFile = this.devPackageFile;
            const appPackageFile = this.projectDir === this.appDir ? buildPackageFile : path.join(this.appDir, "package.json");
            yield bluebird_1.Promise.all(Array.from(new Set([buildPackageFile, appPackageFile]), promisifed_fs_1.parseJsonFile))
                .then((result) => {
                this.metadata = result[result.length - 1];
                this.devMetadata = result[0];
                this.checkMetadata(appPackageFile);
                this.electronVersion = util_1.getElectronVersion(this.devMetadata, buildPackageFile);
            });
            const cleanupTasks = [];
            return promise_1.executeFinally(this.doBuild(cleanupTasks), error => promise_1.all(cleanupTasks.map(it => it())));
        });
    }
    doBuild(cleanupTasks) {
        return __awaiter(this, void 0, void 0, function* () {
            const distTasks = [];
            for (let platform of normalizePlatforms(this.options.platform)) {
                const helper = this.createHelper(platform, cleanupTasks);
                const archs = platform === "darwin" ? ["x64"] : (this.options.arch == null || this.options.arch === "all" ? ["ia32", "x64"] : [this.options.arch]);
                for (let arch of archs) {
                    yield this.installAppDependencies(arch);
                    const outDir = path.join(this.projectDir, "dist", this.metadata.name + "-" + platform + "-" + arch);
                    yield helper.pack(platform, arch, outDir);
                    if (this.options.dist) {
                        distTasks.push(helper.packageInDistributableFormat(outDir, arch));
                    }
                }
            }
            return yield bluebird_1.Promise.all(distTasks);
        });
    }
    createHelper(platform, cleanupTasks) {
        switch (platform) {
            case "darwin":
            case "osx":
                {
                    const helperClass = require("./macPackager").default;
                    return new helperClass(this, cleanupTasks);
                }
            case "win32":
            case "win":
            case "windows":
                {
                    const helperClass = require("./winPackager").default;
                    return new helperClass(this, cleanupTasks);
                }
            case "linux":
                {
                    const helperClass = require("./linuxPackager").default;
                    return new helperClass(this);
                }
            default:
                throw new Error("Unsupported platform: " + platform);
        }
    }
    computeAppDirectory() {
        let customAppPath = this.options.appDir;
        let required = true;
        if (customAppPath == null) {
            customAppPath = util_1.DEFAULT_APP_DIR_NAME;
            required = false;
        }
        let absoluteAppPath = path.join(this.projectDir, customAppPath);
        try {
            fs.accessSync(absoluteAppPath);
        }
        catch (e) {
            if (required) {
                throw new Error(customAppPath + " doesn't exists, " + e.message);
            }
            else {
                this.isTwoPackageJsonProjectLayoutUsed = false;
                return this.projectDir;
            }
        }
        return absoluteAppPath;
    }
    checkMetadata(appPackageFile) {
        const reportError = (missedFieldName) => {
            throw new Error("Please specify '" + missedFieldName + "' in the application package.json ('" + appPackageFile + "')");
        };
        const metadata = this.metadata;
        if (metadata.name == null) {
            reportError("name");
        }
        else if (metadata.description == null) {
            reportError("description");
        }
        else if (metadata.version == null) {
            reportError("version");
        }
        else if (metadata.build == null) {
            throw new Error("Please specify 'build' configuration in the application package.json ('" + appPackageFile + "'), at least\n\n" +
                JSON.stringify({
                    build: {
                        "app-bundle-id": "your.id",
                        "app-category-type": "your.app.category.type",
                        "iconUrl": "see https://github.com/develar/electron-complete-builder#in-short",
                    }
                }, null, "  ") + "\n\n is required.\n");
        }
        else if (metadata.author == null) {
            reportError("author");
        }
    }
    installAppDependencies(arch) {
        if (this.isTwoPackageJsonProjectLayoutUsed) {
            return util_1.installDependencies(this.appDir, arch, this.electronVersion);
        }
        else {
            util_1.log("Skipping app dependencies installation because dev and app dependencies are not separated");
            return Promise.resolve(null);
        }
    }
}
exports.Packager = Packager;
function normalizePlatforms(platforms) {
    if (platforms == null || platforms.length === 0) {
        return [process.platform];
    }
    else if (platforms[0] === "all") {
        if (process.platform === "darwin") {
            return ["darwin", "linux", "win32"];
        }
        else if (process.platform === "linux") {
            return ["linux", "win32"];
        }
        else {
            return ["win32"];
        }
    }
    else {
        return platforms;
    }
}
//# sourceMappingURL=packager.js.map