ns-bundle

#!/usr/bin/env node

const { spawn } = require("child_process");
const { resolve: pathResolve } = require("path");
const { existsSync } = require("fs");
const { getPackageJson } = require("../projectHelpers");

const PROJECT_DIR = pathResolve(__dirname, "../../../");
const packageJson = getPackageJson(PROJECT_DIR);

if (!process.env.npm_config_argv) {
    throwError({message: "No flags provided."});
}

const npmArgs = JSON.parse(process.env.npm_config_argv).original;
const tnsArgs = getTnsArgs(npmArgs).map(escape);
const flags = npmArgs.filter(a => a.startsWith("--")).map(a => a.substring(2));
const options = getOptions(flags);

function getTnsArgs(args) {
    const other = [
        "run",
        "ns-bundle",
        "--android",
        "--ios",
        "--build-app",
        "--start-app",
        "--uglify",
        "--nobundle",
    ];

    return args.filter(a => !other.includes(a));
}

function escape(arg) {
    return `"${arg}"`;
}

execute(options);

function execute(options) {
    let commands = [];
    const platform = options.platform;

    if (options.bundle) {
        commands.push(() => cleanApp(platform));
        commands.push(() => webpack(platform));
    }

    if (platform === "android") {
        commands.push(() => gradlewClean());
    }

    // If "build-app" or "start-app" is specified,
    // the respective command should be run last.
    // Otherwise, the app should be just prepared.
    if (options.command) {
        commands.push(() => runTns(options.command, platform));
    } else {
        commands.shift(() => runTns("prepare", platform))
    }

    return commands.reduce((current, next) => current.then(next), Promise.resolve());
}

// Clear platform/**/app folder contents
function cleanApp(platform) {
    return new Promise((resolve, reject) => {
        spawnChildProcess(true, "tns", "clean-app", platform)
            .then(resolve)
            .catch(throwError)
    });
}

function gradlewClean() {
    return new Promise((resolve, reject) => {
        const platformsPath = pathResolve(PROJECT_DIR, "platforms", "android")
        const gradlew = pathResolve(platformsPath, "gradlew");
        if (!existsSync(gradlew)) {
            resolve();
        }

        spawnChildProcess(true, gradlew, "-p", platformsPath, "clean")
            .then(resolve)
            .catch(throwError);
    });
}

function webpack(platform) {
    return new Promise(function (resolve, reject) {
        console.log(`Running webpack for ${platform}...`);

        const args = [
            true, // show output on console
            `webpack`,
            `--config=webpack.config.js`,
            `--progress`,
            `--env.${platform}`,
            process.env.npm_config_uglify && `--env.uglify`,
        ];

        spawnChildProcess(...args)
            .then(resolve)
            .catch(throwError);
    });
}

function runTns(command, platform) {
    return new Promise((resolve, reject) => {
        console.log(`Running tns ${command}...`);

        spawnChildProcess(true, "tns", command, platform, "--bundle", "--disable-npm-install", ...tnsArgs)
            .then(resolve)
            .catch(throwError);
    });
}

function getOptions(flags) {
    let options = {};
    options.platform = getPlatform(flags);
    options.command = getCommand(flags);
    options.bundle = !flags.includes("nobundle");

    return options;
}

function getPlatform(flags) {
    if (flags.includes("android") && flags.includes("ios")) {
        throwError({message: "You cannot use both --android and --ios flags!"});
    }

    if (flags.includes("android")) {
        return "android";
    } else if (flags.includes("ios")) {
        return "ios";
    } else {
        throwError({message: "You must provide a target platform! Use either --android, or --ios flag."});
    }
}

function getCommand(flags) {
    if (flags.includes("start-app") && flags.includes("build-app")) {
        throwError({message: "You cannot use both --start-app and --build-app flags!"});
    }

    if (flags.includes("start-app")) {
        return "run";
    } else if (flags.includes("build-app")) {
        return "build";
    }
}

function spawnChildProcess(shouldPrintOutput, command, ...args) {
    const stdio = shouldPrintOutput ? "inherit" : "ignore";

    return new Promise((resolve, reject) => {
            const childProcess = spawn(command, args, { stdio, pwd: PROJECT_DIR, shell: true });

            childProcess.on("close", (code) => {
                if (code === 0) {
                    resolve();
                } else {
                    reject({
                        code,
                        message: `child process exited with code ${code}`,
                    });
                }
            });
    });
}

function throwError(error) {
    console.error(error.message);
    process.exit(error.code || 1);
}