ns-bundle

#!/usr/bin/env node

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

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

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

const escapeWithQuotes = arg => `"${arg}"`;
const isTnsCommand = flag => flag.endsWith("-app");
const isEnvCommand = flag => flag.indexOf("env.") > -1;
const shouldUglify = () => process.env.npm_config_uglify;
const shouldSnapshot = platform => platform == "android" &&
    require("os").type() != "Windows_NT" &&
    process.env.npm_config_snapshot;

const npmArgs = JSON.parse(process.env.npm_config_argv).original;
const tnsArgs = getTnsArgs(npmArgs).map(escapeWithQuotes);
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",
        "--uglify",
        "--snapshot",
        "--nobundle",
    ];

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

execute(options);

function execute(options) {
    const platform = options.platform;
    let commands = [ 
        () => runTns("prepare", platform) 
    ];

    if (options.bundle) {
        commands = [
            ...commands,
            () => cleanApp(platform),
            () => cleanSnapshotArtefacts(),
            () => cleanBuildArtefacts(platform),
            () => webpack(platform, options.env),
        ];
    }

    if (shouldSnapshot(platform)) {
        commands.push(() => installSnapshotArtefacts());
    }
    
    // If "build-app" or "start-app" is specified,
    // the respective command should be run last.
    if (options.command) {
        commands.push(() => runTns(options.command, platform));
    }
    return commands.reduce((current, next) => current.then(next), Promise.resolve());
}

function cleanBuildArtefacts(platform) {
    return new Promise((resolve, reject) => {
        if (platform !== "android") {
            return resolve();
        }

        getTnsVersion().then(version => {
            // the android build artefacts should be cleaned manually
            // for nativescript-cli v3.0.1 and below or if using uglify
            if (!isVersionGte(version, "3.0.1") || shouldUglify()) {
                gradlewClean().then(resolve).catch(throwError);
            } else {
                return resolve();
            }
        }).catch(throwError);
    });
}

function cleanSnapshotArtefacts() {
    require("../snapshot/android/project-snapshot-generator").cleanSnapshotArtefacts(PROJECT_DIR);
}

function installSnapshotArtefacts() {
    require("../snapshot/android/project-snapshot-generator").installSnapshotArtefacts(PROJECT_DIR);
}

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

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

function getTnsVersion() {
    return new Promise((resolve, reject) => {
        const childProcess = spawn("tns", ["--version"], { shell: true });

        childProcess.stdout.on("data", resolve);

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

function versionToNumber(version) {
    const VERSION_MATCHER = /(\d+)\.(\d+)\.(\d+)/;

    return Number(VERSION_MATCHER.exec(version).splice(1).join(""));
}

// Clear platform/**/app folder contents
function cleanApp(platform) {
    return new Promise((resolve, reject) => {

        spawnChildProcess("tns", "clean-app", platform)
            .then(resolve)
            .catch(throwError)
    });
}

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

        const args = [
            `webpack`,
            `--config=webpack.config.js`,
            `--progress`,
            `--env.${platform}`,
            ...env.map(item => `--${item}`),
            shouldUglify() && `--env.uglify`,
            shouldSnapshot(platform) && `--env.snapshot`
        ].filter(a => !!a);

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

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

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

function getOptions(flags) {
    return {
        platform: getPlatform(flags),
        command: getCommand(flags),
        env: flags.filter(isEnvCommand),
        bundle: !flags.includes("nobundle"),
    };
}


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) {
    const commands = flags.filter(isTnsCommand);
    if (commands.length > 1) {
        throwError({message: `You can't use ${commands.join(", ")} together!`});
    }

    return commands.length && commands[0].replace(/-app/, "");
}

function spawnChildProcess(command, ...args) {
    return new Promise((resolve, reject) => {
        const escapedArgs = args.map(escapeWithQuotes)

        const childProcess = spawn(command, escapedArgs, {
            stdio: "inherit",
            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);
}