text: "use strict";
  Object.defineProperty(exports, "__esModule", { value: true });
  var path_1 = require("path");
  var fs_extra_1 = require("fs-extra");
  var logger_1 = require("../logger/logger");
  var helpers_1 = require("./helpers");
  var file_cache_1 = require("./file-cache");
  var Constants = require("./constants");
  /**
   * Create a context object which is used by all the build tasks.
   * Filling the config data uses the following hierarchy, which will
   * keep going down the list until it, or if it, finds data.
   *
   * 1) Get from the passed in context variable
   * 2) Get from the config file set using the command-line args
   * 3) Get from environment variable
   * 4) Get from package.json config property
   * 5) Get environment variables
   *
   * Lastly, Ionic's default configs will always fill in any data
   * which is missing from the user's data.
   */
  function generateContext(context) {
      if (!context) {
          context = {};
          context.fileCache = new file_cache_1.FileCache();
      }
      context.isProd = [
          context.isProd,
          hasArg('--prod')
      ].find(function (val) { return typeof val === 'boolean'; });
      setProcessEnvVar(Constants.ENV_VAR_IONIC_ENV, (context.isProd ? Constants.ENV_VAR_PROD : Constants.ENV_VAR_DEV));
      // If context is prod then the following flags must be set to true
      context.runAot = [
          context.runAot,
          context.isProd || hasArg('--aot'),
      ].find(function (val) { return typeof val === 'boolean'; });
      context.runMinifyJs = [
          context.runMinifyJs,
          context.isProd || hasArg('--minifyJs')
      ].find(function (val) { return typeof val === 'boolean'; });
      context.runMinifyCss = [
          context.runMinifyCss,
          context.isProd || hasArg('--minifyCss')
      ].find(function (val) { return typeof val === 'boolean'; });
      context.optimizeJs = [
          context.optimizeJs,
          context.isProd || hasArg('--optimizeJs')
      ].find(function (val) { return typeof val === 'boolean'; });
      if (typeof context.isWatch !== 'boolean') {
          context.isWatch = hasArg('--watch');
      }
      context.rootDir = path_1.resolve(context.rootDir || getConfigValue(context, '--rootDir', null, Constants.ENV_VAR_ROOT_DIR, Constants.ENV_VAR_ROOT_DIR.toLowerCase(), processCwd));
      setProcessEnvVar(Constants.ENV_VAR_ROOT_DIR, context.rootDir);
      logger_1.Logger.debug("rootDir set to " + context.rootDir);
      context.tmpDir = path_1.resolve(context.tmpDir || getConfigValue(context, '--tmpDir', null, Constants.ENV_VAR_TMP_DIR, Constants.ENV_VAR_TMP_DIR.toLowerCase(), path_1.join(context.rootDir, Constants.TMP_DIR)));
      setProcessEnvVar(Constants.ENV_VAR_TMP_DIR, context.tmpDir);
      logger_1.Logger.debug("tmpDir set to " + context.tmpDir);
      context.srcDir = path_1.resolve(context.srcDir || getConfigValue(context, '--srcDir', null, Constants.ENV_VAR_SRC_DIR, Constants.ENV_VAR_SRC_DIR.toLowerCase(), path_1.join(context.rootDir, Constants.SRC_DIR)));
      setProcessEnvVar(Constants.ENV_VAR_SRC_DIR, context.srcDir);
      logger_1.Logger.debug("srcDir set to " + context.srcDir);
      var deepLinksDir = path_1.resolve(getConfigValue(context, '--deepLinksDir', null, Constants.ENV_VAR_DEEPLINKS_DIR, Constants.ENV_VAR_DEEPLINKS_DIR.toLowerCase(), context.srcDir));
      setProcessEnvVar(Constants.ENV_VAR_DEEPLINKS_DIR, deepLinksDir);
      logger_1.Logger.debug("deepLinksDir set to " + deepLinksDir);
      context.wwwDir = path_1.resolve(context.wwwDir || getConfigValue(context, '--wwwDir', null, Constants.ENV_VAR_WWW_DIR, Constants.ENV_VAR_WWW_DIR.toLowerCase(), path_1.join(context.rootDir, Constants.WWW_DIR)));
      setProcessEnvVar(Constants.ENV_VAR_WWW_DIR, context.wwwDir);
      logger_1.Logger.debug("wwwDir set to " + context.wwwDir);
      context.wwwIndex = getConfigValue(context, '--wwwIndex', null, Constants.ENV_VAR_HTML_TO_SERVE, Constants.ENV_VAR_HTML_TO_SERVE.toLowerCase(), 'index.html');
      setProcessEnvVar(Constants.ENV_VAR_HTML_TO_SERVE, context.wwwIndex);
      logger_1.Logger.debug("wwwIndex set to " + context.wwwIndex);
      context.buildDir = path_1.resolve(context.buildDir || getConfigValue(context, '--buildDir', null, Constants.ENV_VAR_BUILD_DIR, Constants.ENV_VAR_BUILD_DIR.toLowerCase(), path_1.join(context.wwwDir, Constants.BUILD_DIR)));
      setProcessEnvVar(Constants.ENV_VAR_BUILD_DIR, context.buildDir);
      logger_1.Logger.debug("buildDir set to " + context.buildDir);
      context.pagesDir = path_1.resolve(context.pagesDir || getConfigValue(context, '--pagesDir', null, Constants.ENV_VAR_PAGES_DIR, Constants.ENV_VAR_PAGES_DIR.toLowerCase(), path_1.join(context.srcDir, 'pages')));
      setProcessEnvVar(Constants.ENV_VAR_PAGES_DIR, context.pagesDir);
      logger_1.Logger.debug("pagesDir set to " + context.pagesDir);
      context.componentsDir = path_1.resolve(context.componentsDir || getConfigValue(context, '--componentsDir', null, Constants.ENV_VAR_COMPONENTS_DIR, Constants.ENV_VAR_COMPONENTS_DIR.toLowerCase(), path_1.join(context.srcDir, 'components')));
      setProcessEnvVar(Constants.ENV_VAR_COMPONENTS_DIR, context.componentsDir);
      logger_1.Logger.debug("componentsDir set to " + context.componentsDir);
      context.directivesDir = path_1.resolve(context.directivesDir || getConfigValue(context, '--directivesDir', null, Constants.ENV_VAR_DIRECTIVES_DIR, Constants.ENV_VAR_DIRECTIVES_DIR.toLowerCase(), path_1.join(context.srcDir, 'directives')));
      setProcessEnvVar(Constants.ENV_VAR_DIRECTIVES_DIR, context.directivesDir);
      logger_1.Logger.debug("directivesDir set to " + context.directivesDir);
      context.pipesDir = path_1.resolve(context.pipesDir || getConfigValue(context, '--pipesDir', null, Constants.ENV_VAR_PIPES_DIR, Constants.ENV_VAR_PIPES_DIR.toLowerCase(), path_1.join(context.srcDir, 'pipes')));
      setProcessEnvVar(Constants.ENV_VAR_PIPES_DIR, context.pipesDir);
      logger_1.Logger.debug("pipesDir set to " + context.pipesDir);
      context.providersDir = path_1.resolve(context.providersDir || getConfigValue(context, '--providersDir', null, Constants.ENV_VAR_PROVIDERS_DIR, Constants.ENV_VAR_PROVIDERS_DIR.toLowerCase(), path_1.join(context.srcDir, 'providers')));
      setProcessEnvVar(Constants.ENV_VAR_PROVIDERS_DIR, context.providersDir);
      logger_1.Logger.debug("providersDir set to " + context.providersDir);
      context.nodeModulesDir = path_1.join(context.rootDir, Constants.NODE_MODULES);
      setProcessEnvVar(Constants.ENV_VAR_NODE_MODULES_DIR, context.nodeModulesDir);
      logger_1.Logger.debug("nodeModulesDir set to " + context.nodeModulesDir);
      context.ionicAngularDir = path_1.resolve(context.ionicAngularDir || getConfigValue(context, '--ionicAngularDir', null, Constants.ENV_VAR_IONIC_ANGULAR_DIR, Constants.ENV_VAR_IONIC_ANGULAR_DIR.toLowerCase(), path_1.join(context.nodeModulesDir, Constants.IONIC_ANGULAR)));
      setProcessEnvVar(Constants.ENV_VAR_IONIC_ANGULAR_DIR, context.ionicAngularDir);
      logger_1.Logger.debug("ionicAngularDir set to " + context.ionicAngularDir);
      var angularDir = path_1.resolve(getConfigValue(context, '--angularDir', null, Constants.ENV_VAR_AT_ANGULAR_DIR, Constants.ENV_VAR_AT_ANGULAR_DIR.toLowerCase(), path_1.join(context.nodeModulesDir, Constants.AT_ANGULAR)));
      setProcessEnvVar(Constants.ENV_VAR_AT_ANGULAR_DIR, angularDir);
      logger_1.Logger.debug("angularDir set to " + angularDir);
      var ionicAngularTemplatesDir = path_1.join(context.ionicAngularDir, 'templates');
      setProcessEnvVar(Constants.ENV_VAR_IONIC_ANGULAR_TEMPLATE_DIR, ionicAngularTemplatesDir);
      logger_1.Logger.debug("ionicAngularTemplatesDir set to " + ionicAngularTemplatesDir);
      context.platform = getConfigValue(context, '--platform', null, Constants.ENV_VAR_PLATFORM, null, null);
      setProcessEnvVar(Constants.ENV_VAR_PLATFORM, context.platform);
      logger_1.Logger.debug("platform set to " + context.platform);
      context.target = getConfigValue(context, '--target', null, Constants.ENV_VAR_TARGET, null, null);
      setProcessEnvVar(Constants.ENV_VAR_TARGET, context.target);
      logger_1.Logger.debug("target set to " + context.target);
      var ionicAngularEntryPoint = path_1.resolve(getConfigValue(context, '--ionicAngularEntryPoint', null, Constants.ENV_VAR_IONIC_ANGULAR_ENTRY_POINT, Constants.ENV_VAR_IONIC_ANGULAR_ENTRY_POINT.toLowerCase(), path_1.join(context.ionicAngularDir, 'index.js')));
      setProcessEnvVar(Constants.ENV_VAR_IONIC_ANGULAR_ENTRY_POINT, ionicAngularEntryPoint);
      logger_1.Logger.debug("ionicAngularEntryPoint set to " + ionicAngularEntryPoint);
      var appScriptsDir = path_1.join(__dirname, '..', '..');
      setProcessEnvVar(Constants.ENV_VAR_APP_SCRIPTS_DIR, appScriptsDir);
      logger_1.Logger.debug("appScriptsDir set to " + appScriptsDir);
      var generateSourceMap = getConfigValue(context, '--generateSourceMap', null, Constants.ENV_VAR_GENERATE_SOURCE_MAP, Constants.ENV_VAR_GENERATE_SOURCE_MAP.toLowerCase(), context.isProd || context.runMinifyJs ? null : 'true');
      setProcessEnvVar(Constants.ENV_VAR_GENERATE_SOURCE_MAP, generateSourceMap);
      logger_1.Logger.debug("generateSourceMap set to " + generateSourceMap);
      var sourceMapTypeValue = getConfigValue(context, '--sourceMapType', null, Constants.ENV_VAR_SOURCE_MAP_TYPE, Constants.ENV_VAR_SOURCE_MAP_TYPE.toLowerCase(), Constants.SOURCE_MAP_TYPE_EXPENSIVE);
      setProcessEnvVar(Constants.ENV_VAR_SOURCE_MAP_TYPE, sourceMapTypeValue);
      logger_1.Logger.debug("sourceMapType set to " + sourceMapTypeValue);
      var tsConfigPathValue = path_1.resolve(getConfigValue(context, '--tsconfig', null, Constants.ENV_TS_CONFIG, Constants.ENV_TS_CONFIG.toLowerCase(), path_1.join(context.rootDir, 'tsconfig.json')));
      setProcessEnvVar(Constants.ENV_TS_CONFIG, tsConfigPathValue);
      logger_1.Logger.debug("tsconfig set to " + tsConfigPathValue);
      var readConfigJson = getConfigValue(context, '--readConfigJson', null, Constants.ENV_READ_CONFIG_JSON, Constants.ENV_READ_CONFIG_JSON.toLowerCase(), 'true');
      setProcessEnvVar(Constants.ENV_READ_CONFIG_JSON, readConfigJson);
      logger_1.Logger.debug("readConfigJson set to " + readConfigJson);
      var appEntryPointPathValue = path_1.resolve(getConfigValue(context, '--appEntryPoint', null, Constants.ENV_APP_ENTRY_POINT, Constants.ENV_APP_ENTRY_POINT.toLowerCase(), path_1.join(context.srcDir, 'app', 'main.ts')));
      setProcessEnvVar(Constants.ENV_APP_ENTRY_POINT, appEntryPointPathValue);
      logger_1.Logger.debug("appEntryPoint set to " + appEntryPointPathValue);
      context.appNgModulePath = path_1.resolve(getConfigValue(context, '--appNgModulePath', null, Constants.ENV_APP_NG_MODULE_PATH, Constants.ENV_APP_NG_MODULE_PATH.toLowerCase(), path_1.join(context.srcDir, 'app', 'app.module.ts')));
      setProcessEnvVar(Constants.ENV_APP_NG_MODULE_PATH, context.appNgModulePath);
      logger_1.Logger.debug("appNgModulePath set to " + context.appNgModulePath);
      var appNgModuleClass = getConfigValue(context, '--appNgModuleClass', null, Constants.ENV_APP_NG_MODULE_CLASS, Constants.ENV_APP_NG_MODULE_CLASS.toLowerCase(), 'AppModule');
      setProcessEnvVar(Constants.ENV_APP_NG_MODULE_CLASS, appNgModuleClass);
      logger_1.Logger.debug("appNgModuleClass set to " + appNgModuleClass);
      var pathToGlobUtil = path_1.join(getProcessEnvVar(Constants.ENV_VAR_APP_SCRIPTS_DIR), 'dist', 'util', 'glob-util.js');
      setProcessEnvVar(Constants.ENV_GLOB_UTIL, pathToGlobUtil);
      logger_1.Logger.debug("pathToGlobUtil set to " + pathToGlobUtil);
      var cleanBeforeCopy = getConfigValue(context, '--cleanBeforeCopy', null, Constants.ENV_CLEAN_BEFORE_COPY, Constants.ENV_CLEAN_BEFORE_COPY.toLowerCase(), null);
      setProcessEnvVar(Constants.ENV_CLEAN_BEFORE_COPY, cleanBeforeCopy);
      logger_1.Logger.debug("cleanBeforeCopy set to " + cleanBeforeCopy);
      var closureCompilerJarPath = path_1.join(getProcessEnvVar(Constants.ENV_VAR_APP_SCRIPTS_DIR), 'bin', 'closure-compiler.jar');
      setProcessEnvVar(Constants.ENV_CLOSURE_JAR, closureCompilerJarPath);
      logger_1.Logger.debug("closureCompilerJarPath set to " + closureCompilerJarPath);
      context.outputJsFileName = getConfigValue(context, '--outputJsFileName', null, Constants.ENV_OUTPUT_JS_FILE_NAME, Constants.ENV_OUTPUT_JS_FILE_NAME.toLowerCase(), 'main.js');
      setProcessEnvVar(Constants.ENV_OUTPUT_JS_FILE_NAME, context.outputJsFileName);
      logger_1.Logger.debug("outputJsFileName set to " + context.outputJsFileName);
      context.outputCssFileName = getConfigValue(context, '--outputCssFileName', null, Constants.ENV_OUTPUT_CSS_FILE_NAME, Constants.ENV_OUTPUT_CSS_FILE_NAME.toLowerCase(), 'main.css');
      setProcessEnvVar(Constants.ENV_OUTPUT_CSS_FILE_NAME, context.outputCssFileName);
      logger_1.Logger.debug("outputCssFileName set to " + context.outputCssFileName);
      var webpackFactoryPath = path_1.join(getProcessEnvVar(Constants.ENV_VAR_APP_SCRIPTS_DIR), 'dist', 'webpack', 'ionic-webpack-factory.js');
      setProcessEnvVar(Constants.ENV_WEBPACK_FACTORY, webpackFactoryPath);
      logger_1.Logger.debug("webpackFactoryPath set to " + webpackFactoryPath);
      var webpackLoaderPath = path_1.join(getProcessEnvVar(Constants.ENV_VAR_APP_SCRIPTS_DIR), 'dist', 'webpack', 'loader.js');
      setProcessEnvVar(Constants.ENV_WEBPACK_LOADER, webpackLoaderPath);
      logger_1.Logger.debug("webpackLoaderPath set to " + webpackLoaderPath);
      var optimizationLoaderPath = path_1.join(getProcessEnvVar(Constants.ENV_VAR_APP_SCRIPTS_DIR), 'dist', 'webpack', 'optimization-loader.js');
      setProcessEnvVar(Constants.ENV_OPTIMIZATION_LOADER, optimizationLoaderPath);
      logger_1.Logger.debug("optimizationLoaderPath set to " + optimizationLoaderPath);
      var aotWriteToDisk = getConfigValue(context, '--aotWriteToDisk', null, Constants.ENV_AOT_WRITE_TO_DISK, Constants.ENV_AOT_WRITE_TO_DISK.toLowerCase(), null);
      setProcessEnvVar(Constants.ENV_AOT_WRITE_TO_DISK, aotWriteToDisk);
      logger_1.Logger.debug("aotWriteToDisk set to " + aotWriteToDisk);
      var printOriginalDependencyTree = getConfigValue(context, '--printOriginalDependencyTree', null, Constants.ENV_PRINT_ORIGINAL_DEPENDENCY_TREE, Constants.ENV_PRINT_ORIGINAL_DEPENDENCY_TREE.toLowerCase(), null);
      setProcessEnvVar(Constants.ENV_PRINT_ORIGINAL_DEPENDENCY_TREE, printOriginalDependencyTree);
      logger_1.Logger.debug("printOriginalDependencyTree set to " + printOriginalDependencyTree);
      var printModifiedDependencyTree = getConfigValue(context, '--printModifiedDependencyTree', null, Constants.ENV_PRINT_MODIFIED_DEPENDENCY_TREE, Constants.ENV_PRINT_MODIFIED_DEPENDENCY_TREE.toLowerCase(), null);
      setProcessEnvVar(Constants.ENV_PRINT_MODIFIED_DEPENDENCY_TREE, printModifiedDependencyTree);
      logger_1.Logger.debug("printModifiedDependencyTree set to " + printModifiedDependencyTree);
      var printWebpackDependencyTree = getConfigValue(context, '--printWebpackDependencyTree', null, Constants.ENV_PRINT_WEBPACK_DEPENDENCY_TREE, Constants.ENV_PRINT_WEBPACK_DEPENDENCY_TREE.toLowerCase(), null);
      setProcessEnvVar(Constants.ENV_PRINT_WEBPACK_DEPENDENCY_TREE, printWebpackDependencyTree);
      logger_1.Logger.debug("printWebpackDependencyTree set to " + printWebpackDependencyTree);
      var bailOnLintError = getConfigValue(context, '--bailOnLintError', null, Constants.ENV_BAIL_ON_LINT_ERROR, Constants.ENV_BAIL_ON_LINT_ERROR.toLowerCase(), null);
      setProcessEnvVar(Constants.ENV_BAIL_ON_LINT_ERROR, bailOnLintError);
      logger_1.Logger.debug("bailOnLintError set to " + bailOnLintError);
      var enableLint = getConfigValue(context, '--enableLint', null, Constants.ENV_ENABLE_LINT, Constants.ENV_ENABLE_LINT.toLowerCase(), 'true');
      setProcessEnvVar(Constants.ENV_ENABLE_LINT, enableLint);
      logger_1.Logger.debug("enableLint set to " + enableLint);
      var disableLogging = getConfigValue(context, '--disableLogging', null, Constants.ENV_DISABLE_LOGGING, Constants.ENV_DISABLE_LOGGING.toLowerCase(), null);
      setProcessEnvVar(Constants.ENV_DISABLE_LOGGING, disableLogging);
      logger_1.Logger.debug("disableLogging set to " + disableLogging);
      var startWatchTimeout = getConfigValue(context, '--startWatchTimeout', null, Constants.ENV_START_WATCH_TIMEOUT, Constants.ENV_START_WATCH_TIMEOUT.toLowerCase(), '3000');
      setProcessEnvVar(Constants.ENV_START_WATCH_TIMEOUT, startWatchTimeout);
      logger_1.Logger.debug("startWatchTimeout set to " + startWatchTimeout);
      var ngModuleFileNameSuffix = getConfigValue(context, '--ngModuleFileNameSuffix', null, Constants.ENV_NG_MODULE_FILE_NAME_SUFFIX, Constants.ENV_NG_MODULE_FILE_NAME_SUFFIX.toLowerCase(), '.module.ts');
      setProcessEnvVar(Constants.ENV_NG_MODULE_FILE_NAME_SUFFIX, ngModuleFileNameSuffix);
      logger_1.Logger.debug("ngModuleFileNameSuffix set to " + ngModuleFileNameSuffix);
      /* Provider Path Stuff */
      setProcessEnvVar(Constants.ENV_ACTION_SHEET_CONTROLLER_CLASSNAME, 'ActionSheetController');
      setProcessEnvVar(Constants.ENV_ACTION_SHEET_CONTROLLER_PATH, path_1.join(context.ionicAngularDir, 'components', 'action-sheet', 'action-sheet-controller.js'));
      setProcessEnvVar(Constants.ENV_ACTION_SHEET_VIEW_CONTROLLER_PATH, path_1.join(context.ionicAngularDir, 'components', 'action-sheet', 'action-sheet.js'));
      setProcessEnvVar(Constants.ENV_ACTION_SHEET_COMPONENT_PATH, path_1.join(context.ionicAngularDir, 'components', 'action-sheet', 'action-sheet-component.js'));
      setProcessEnvVar(Constants.ENV_ACTION_SHEET_COMPONENT_FACTORY_PATH, path_1.join(context.ionicAngularDir, 'components', 'action-sheet', 'action-sheet-component.ngfactory.js'));
      setProcessEnvVar(Constants.ENV_ALERT_CONTROLLER_CLASSNAME, 'AlertController');
      setProcessEnvVar(Constants.ENV_ALERT_CONTROLLER_PATH, path_1.join(context.ionicAngularDir, 'components', 'alert', 'alert-controller.js'));
      setProcessEnvVar(Constants.ENV_ALERT_VIEW_CONTROLLER_PATH, path_1.join(context.ionicAngularDir, 'components', 'alert', 'alert.js'));
      setProcessEnvVar(Constants.ENV_ALERT_COMPONENT_PATH, path_1.join(context.ionicAngularDir, 'components', 'alert', 'alert-component.js'));
      setProcessEnvVar(Constants.ENV_ALERT_COMPONENT_FACTORY_PATH, path_1.join(context.ionicAngularDir, 'components', 'alert', 'alert-component.ngfactory.js'));
      setProcessEnvVar(Constants.ENV_APP_ROOT_COMPONENT_PATH, path_1.join(context.ionicAngularDir, 'components', 'app', 'app-root.js'));
      setProcessEnvVar(Constants.ENV_LOADING_CONTROLLER_CLASSNAME, 'LoadingController');
      setProcessEnvVar(Constants.ENV_LOADING_CONTROLLER_PATH, path_1.join(context.ionicAngularDir, 'components', 'loading', 'loading-controller.js'));
      setProcessEnvVar(Constants.ENV_LOADING_VIEW_CONTROLLER_PATH, path_1.join(context.ionicAngularDir, 'components', 'loading', 'loading.js'));
      setProcessEnvVar(Constants.ENV_LOADING_COMPONENT_PATH, path_1.join(context.ionicAngularDir, 'components', 'loading', 'loading-component.js'));
      setProcessEnvVar(Constants.ENV_LOADING_COMPONENT_FACTORY_PATH, path_1.join(context.ionicAngularDir, 'components', 'loading', 'loading-component.ngfactory.js'));
      setProcessEnvVar(Constants.ENV_MODAL_CONTROLLER_CLASSNAME, 'ModalController');
      setProcessEnvVar(Constants.ENV_MODAL_CONTROLLER_PATH, path_1.join(context.ionicAngularDir, 'components', 'modal', 'modal-controller.js'));
      setProcessEnvVar(Constants.ENV_MODAL_VIEW_CONTROLLER_PATH, path_1.join(context.ionicAngularDir, 'components', 'modal', 'modal.js'));
      setProcessEnvVar(Constants.ENV_MODAL_COMPONENT_PATH, path_1.join(context.ionicAngularDir, 'components', 'modal', 'modal-component.js'));
      setProcessEnvVar(Constants.ENV_MODAL_COMPONENT_FACTORY_PATH, path_1.join(context.ionicAngularDir, 'components', 'modal', 'modal-component.ngfactory.js'));
      setProcessEnvVar(Constants.ENV_PICKER_CONTROLLER_CLASSNAME, 'PickerController');
      setProcessEnvVar(Constants.ENV_PICKER_CONTROLLER_PATH, path_1.join(context.ionicAngularDir, 'components', 'picker', 'picker-controller.js'));
      setProcessEnvVar(Constants.ENV_PICKER_VIEW_CONTROLLER_PATH, path_1.join(context.ionicAngularDir, 'components', 'picker', 'picker.js'));
      setProcessEnvVar(Constants.ENV_PICKER_COMPONENT_PATH, path_1.join(context.ionicAngularDir, 'components', 'picker', 'picker-component.js'));
      setProcessEnvVar(Constants.ENV_PICKER_COMPONENT_FACTORY_PATH, path_1.join(context.ionicAngularDir, 'components', 'picker', 'picker-component.ngfactory.js'));
      setProcessEnvVar(Constants.ENV_POPOVER_CONTROLLER_CLASSNAME, 'PopoverController');
      setProcessEnvVar(Constants.ENV_POPOVER_CONTROLLER_PATH, path_1.join(context.ionicAngularDir, 'components', 'popover', 'popover-controller.js'));
      setProcessEnvVar(Constants.ENV_POPOVER_VIEW_CONTROLLER_PATH, path_1.join(context.ionicAngularDir, 'components', 'popover', 'popover.js'));
      setProcessEnvVar(Constants.ENV_POPOVER_COMPONENT_PATH, path_1.join(context.ionicAngularDir, 'components', 'popover', 'popover-component.js'));
      setProcessEnvVar(Constants.ENV_POPOVER_COMPONENT_FACTORY_PATH, path_1.join(context.ionicAngularDir, 'components', 'popover', 'popover-component.ngfactory.js'));
      setProcessEnvVar(Constants.ENV_TOAST_CONTROLLER_CLASSNAME, 'ToastController');
      setProcessEnvVar(Constants.ENV_TOAST_CONTROLLER_PATH, path_1.join(context.ionicAngularDir, 'components', 'toast', 'toast-controller.js'));
      setProcessEnvVar(Constants.ENV_TOAST_VIEW_CONTROLLER_PATH, path_1.join(context.ionicAngularDir, 'components', 'toast', 'toast.js'));
      setProcessEnvVar(Constants.ENV_TOAST_COMPONENT_PATH, path_1.join(context.ionicAngularDir, 'components', 'toast', 'toast-component.js'));
      setProcessEnvVar(Constants.ENV_TOAST_COMPONENT_FACTORY_PATH, path_1.join(context.ionicAngularDir, 'components', 'toast', 'toast-component.ngfactory.js'));
      var parseDeepLinks = getConfigValue(context, '--parseDeepLinks', null, Constants.ENV_PARSE_DEEPLINKS, Constants.ENV_PARSE_DEEPLINKS.toLowerCase(), 'true');
      setProcessEnvVar(Constants.ENV_PARSE_DEEPLINKS, parseDeepLinks);
      logger_1.Logger.debug("parseDeepLinks set to " + parseDeepLinks);
      var purgeDecorators = getConfigValue(context, '--purgeDecorators', null, Constants.ENV_PURGE_DECORATORS, Constants.ENV_PURGE_DECORATORS.toLowerCase(), 'true');
      setProcessEnvVar(Constants.ENV_PURGE_DECORATORS, purgeDecorators);
      logger_1.Logger.debug("purgeDecorators set to " + purgeDecorators);
      /* Experimental Flags */
      var experimentalManualTreeshaking = getConfigValue(context, '--experimentalManualTreeshaking', null, Constants.ENV_EXPERIMENTAL_MANUAL_TREESHAKING, Constants.ENV_EXPERIMENTAL_MANUAL_TREESHAKING.toLowerCase(), null);
      setProcessEnvVar(Constants.ENV_EXPERIMENTAL_MANUAL_TREESHAKING, experimentalManualTreeshaking);
      logger_1.Logger.debug("experimentalManualTreeshaking set to " + experimentalManualTreeshaking);
      var useExperimentalClosure = getConfigValue(context, '--useExperimentalClosure', null, Constants.ENV_USE_EXPERIMENTAL_CLOSURE, Constants.ENV_USE_EXPERIMENTAL_CLOSURE.toLowerCase(), null);
      setProcessEnvVar(Constants.ENV_USE_EXPERIMENTAL_CLOSURE, useExperimentalClosure);
      logger_1.Logger.debug("useExperimentalClosure set to " + useExperimentalClosure);
      var useExperimentalBabili = getConfigValue(context, '--useExperimentalBabili', null, Constants.ENV_USE_EXPERIMENTAL_BABILI, Constants.ENV_USE_EXPERIMENTAL_BABILI.toLowerCase(), null);
      setProcessEnvVar(Constants.ENV_USE_EXPERIMENTAL_BABILI, useExperimentalBabili);
      logger_1.Logger.debug("useExperimentalBabili set to " + useExperimentalBabili);
      // default stand-alone builds to default to es5
      // if closure is being used, don't worry about this as it already automatically converts to ES5
      var buildToEs5 = getConfigValue(context, '--buildToEs5', null, Constants.ENV_BUILD_TO_ES5, Constants.ENV_BUILD_TO_ES5.toLowerCase(), null);
      setProcessEnvVar(Constants.ENV_BUILD_TO_ES5, buildToEs5);
      logger_1.Logger.debug("buildToEs5 set to " + buildToEs5);
      if (!isValidBundler(context.bundler)) {
          context.bundler = bundlerStrategy(context);
          logger_1.Logger.debug("bundler set to " + context.bundler);
      }
      context.inlineTemplates = true;
      checkDebugMode();
      if (helpers_1.getBooleanPropertyValue(Constants.ENV_DISABLE_LOGGING)) {
          console.debug = function () { };
          console.error = function () { };
          console.info = function () { };
          console.log = function () { };
          console.trace = function () { };
          console.warn = function () { };
      }
      return context;
  }
  exports.generateContext = generateContext;
  function getUserConfigFile(context, task, userConfigFile) {
      if (!context) {
          context = generateContext(context);
      }
      if (userConfigFile) {
          return path_1.resolve(userConfigFile);
      }
      var defaultConfig = getConfigValue(context, task.fullArg, task.shortArg, task.envVar, task.packageConfig, null);
      if (defaultConfig) {
          return path_1.join(context.rootDir, defaultConfig);
      }
      return null;
  }
  exports.getUserConfigFile = getUserConfigFile;
  function fillConfigDefaults(userConfigFile, defaultConfigFile) {
      var userConfig = null;
      if (userConfigFile) {
          try {
              // check if exists first, so we can print a more specific error message
              // since required config could also throw MODULE_NOT_FOUND
              fs_extra_1.statSync(userConfigFile);
              // create a fresh copy of the config each time
              userConfig = require(userConfigFile);
              // if user config returns a function call it to determine proper object
              if (typeof userConfig === 'function') {
                  userConfig = userConfig();
              }
          }
          catch (e) {
              if (e.code === 'ENOENT') {
                  console.error("Config file \"" + userConfigFile + "\" not found. Using defaults instead.");
              }
              else {
                  console.error("There was an error in config file \"" + userConfigFile + "\". Using defaults instead.");
                  console.error(e);
              }
          }
      }
      var defaultConfig = require(path_1.join('..', '..', 'config', defaultConfigFile));
      // create a fresh copy of the config each time
      // always assign any default values which were not already supplied by the user
      return helpers_1.objectAssign({}, defaultConfig, userConfig);
  }
  exports.fillConfigDefaults = fillConfigDefaults;
  function bundlerStrategy(context) {
      // 1) User provided a rollup config via cmd line args
      var val = getArgValue('--rollup', '-r');
      if (val) {
          return Constants.BUNDLER_ROLLUP;
      }
      // 2) User provided both a rollup config and webpack config in package.json config
      val = getPackageJsonConfig(context, 'ionic_rollup');
      var webpackVal = getPackageJsonConfig(context, 'ionic_webpack');
      if (val && webpackVal) {
          var bundler = getPackageJsonConfig(context, 'ionic_bundler');
          if (isValidBundler(bundler)) {
              return bundler;
          }
      }
      // 3) User provided a rollup config env var
      val = getProcessEnvVar('ionic_rollup');
      if (val) {
          return Constants.BUNDLER_ROLLUP;
      }
      // 4) User provided a rollup config in package.json config
      val = getPackageJsonConfig(context, 'ionic_rollup');
      if (val) {
          return Constants.BUNDLER_ROLLUP;
      }
      // 5) User set bundler through full arg
      val = getArgValue('--bundler', null);
      if (isValidBundler(val)) {
          return val;
      }
      // 6) User set bundler through package.json config
      val = getPackageJsonConfig(context, 'ionic_bundler');
      if (isValidBundler(val)) {
          return val;
      }
      // 7) User set to use rollup at the bundler
      val = getProcessEnvVar('ionic_bundler');
      if (isValidBundler(val)) {
          return val;
      }
      // 8) Default to use webpack
      return Constants.BUNDLER_WEBPACK;
  }
  exports.bundlerStrategy = bundlerStrategy;
  function isValidBundler(bundler) {
      return (bundler === Constants.BUNDLER_ROLLUP || bundler === Constants.BUNDLER_WEBPACK);
  }
  function getConfigValue(context, argFullName, argShortName, envVarName, packageConfigProp, defaultValue) {
      if (!context) {
          context = generateContext(context);
      }
      // first see if the value was set in the command-line args
      var argVal = getArgValue(argFullName, argShortName);
      if (argVal !== null) {
          return argVal;
      }
      // next see if it was set in the environment variables
      // which also checks if it was set in the package.json config property
      var envVar = getProcessEnvVar(envVarName);
      if (envVar !== null) {
          return envVar;
      }
      var packageConfig = getPackageJsonConfig(context, packageConfigProp);
      if (packageConfig !== null) {
          return packageConfig;
      }
      // return the default if nothing above was found
      return defaultValue;
  }
  exports.getConfigValue = getConfigValue;
  function getArgValue(fullName, shortName) {
      for (var i = 2; i < processArgv.length; i++) {
          var arg = processArgv[i];
          if (arg === fullName || (shortName && arg === shortName)) {
              var val = processArgv[i + 1];
              if (val !== undefined && val !== '') {
                  return val;
              }
          }
      }
      return null;
  }
  function hasConfigValue(context, argFullName, argShortName, envVarName, defaultValue) {
      if (!context) {
          context = generateContext(context);
      }
      if (hasArg(argFullName, argShortName)) {
          return true;
      }
      // next see if it was set in the environment variables
      // which also checks if it was set in the package.json config property
      var envVar = getProcessEnvVar(envVarName);
      if (envVar !== null) {
          return true;
      }
      var packageConfig = getPackageJsonConfig(context, envVarName);
      if (packageConfig !== null) {
          return true;
      }
      // return the default if nothing above was found
      return defaultValue;
  }
  exports.hasConfigValue = hasConfigValue;
  function hasArg(fullName, shortName) {
      if (shortName === void 0) { shortName = null; }
      return !!(processArgv.some(function (a) { return a.toLowerCase() === fullName.toLowerCase(); }) ||
          (shortName !== null && processArgv.some(function (a) { return a.toLowerCase() === shortName.toLowerCase(); })));
  }
  exports.hasArg = hasArg;
  function replacePathVars(context, filePath) {
      if (Array.isArray(filePath)) {
          return filePath.map(function (f) { return replacePathVars(context, f); });
      }
      if (typeof filePath === 'object') {
          var clonedFilePaths = Object.assign({}, filePath);
          for (var key in clonedFilePaths) {
              clonedFilePaths[key] = replacePathVars(context, clonedFilePaths[key]);
          }
          return clonedFilePaths;
      }
      return filePath.replace('{{SRC}}', context.srcDir)
          .replace('{{WWW}}', context.wwwDir)
          .replace('{{TMP}}', context.tmpDir)
          .replace('{{ROOT}}', context.rootDir)
          .replace('{{BUILD}}', context.buildDir);
  }
  exports.replacePathVars = replacePathVars;
  function getNodeBinExecutable(context, cmd) {
      var cmdPath = path_1.join(context.rootDir, 'node_modules', '.bin', cmd);
      try {
          fs_extra_1.accessSync(cmdPath);
      }
      catch (e) {
          cmdPath = null;
      }
      return cmdPath;
  }
  exports.getNodeBinExecutable = getNodeBinExecutable;
  var checkedDebug = false;
  function checkDebugMode() {
      if (!checkedDebug) {
          if (hasArg('--debug') || getProcessEnvVar('ionic_debug_mode') === 'true') {
              processEnv.ionic_debug_mode = 'true';
          }
          checkedDebug = true;
      }
  }
  function isDebugMode() {
      return (processEnv.ionic_debug_mode === 'true');
  }
  exports.isDebugMode = isDebugMode;
  var processArgv;
  function setProcessArgs(argv) {
      processArgv = argv;
  }
  exports.setProcessArgs = setProcessArgs;
  setProcessArgs(process.argv);
  function addArgv(value) {
      processArgv.push(value);
  }
  exports.addArgv = addArgv;
  var processEnv;
  function setProcessEnv(env) {
      processEnv = env;
  }
  exports.setProcessEnv = setProcessEnv;
  setProcessEnv(process.env);
  function setProcessEnvVar(key, value) {
      if (key && value) {
          processEnv[key] = value;
      }
  }
  exports.setProcessEnvVar = setProcessEnvVar;
  function getProcessEnvVar(key) {
      var val = processEnv[key];
      if (val !== undefined) {
          if (val === 'true') {
              return true;
          }
          if (val === 'false') {
              return false;
          }
          return val;
      }
      return null;
  }
  exports.getProcessEnvVar = getProcessEnvVar;
  var processCwd;
  function setCwd(cwd) {
      processCwd = cwd;
  }
  exports.setCwd = setCwd;
  setCwd(process.cwd());
  function getPackageJsonConfig(context, key) {
      var packageJsonData = getAppPackageJsonData(context);
      if (packageJsonData && packageJsonData.config) {
          var val = packageJsonData.config[key];
          if (val !== undefined) {
              if (val === 'true') {
                  return true;
              }
              if (val === 'false') {
                  return false;
              }
              return val;
          }
      }
      return null;
  }
  exports.getPackageJsonConfig = getPackageJsonConfig;
  var appPackageJsonData = null;
  function setAppPackageJsonData(data) {
      appPackageJsonData = data;
  }
  exports.setAppPackageJsonData = setAppPackageJsonData;
  function getAppPackageJsonData(context) {
      if (!appPackageJsonData) {
          try {
              appPackageJsonData = fs_extra_1.readJSONSync(path_1.join(context.rootDir, 'package.json'));
          }
          catch (e) { }
      }
      return appPackageJsonData;
  }
  