ember-cli 7.2.0-beta.1 → 7.3.0-alpha.1

package/packages/blueprint-model/index.js

@@ -0,0 +1,1791 @@
+'use strict';
+
+/**
+@module ember-cli
+*/
+const FileInfo = require('@ember-tooling/blueprint-model/utilities/file-info');
+const { default: chalk } = require('chalk');
+const MarkdownColor = require('@ember-tooling/blueprint-model/utilities/markdown-color');
+const sequence = require('./utilities/sequence');
+const printCommand = require('@ember-tooling/blueprint-model/utilities/print-command');
+const insertIntoFile = require('@ember-tooling/blueprint-model/utilities/insert-into-file');
+const cleanRemove = require('@ember-tooling/blueprint-model/utilities/clean-remove');
+const fs = require('fs-extra');
+const { pluralize } = require('inflection');
+const { minimatch } = require('minimatch');
+const path = require('path');
+const stringUtils = require('ember-cli-string-utils');
+const merge = require('lodash/merge');
+const zipObject = require('lodash/zipObject');
+const intersection = require('lodash/intersection');
+const cloneDeep = require('lodash/cloneDeep');
+const compact = require('lodash/compact');
+const sortBy = require('lodash/sortBy');
+const walkSync = require('walk-sync');
+const SilentError = require('silent-error');
+const CoreObject = require('core-object');
+const EOL = require('os').EOL;
+const logger = require('heimdalljs-logger')('ember-cli:blueprint');
+const normalizeEntityName = require('ember-cli-normalize-entity-name');
+const isAddon = require('@ember-tooling/blueprint-model/utilities/is-addon');
+
+const initialIgnoredFiles = ['.DS_Store'];
+
+/**
+  A blueprint is a bundle of template files with optional install
+  logic.
+
+  Blueprints follow a simple structure. Let's take the built-in
+  `controller` blueprint as an example:
+
+  ```
+  blueprints/controller
+  ├── files
+  │   ├── app
+  │   │   └── __path__
+  │   │       └── __name__.js
+  └── index.js
+
+  blueprints/controller-test
+  ├── files
+  │   └── tests
+  │       └── unit
+  │           └── controllers
+  │               └── __test__.js
+  └── index.js
+  ```
+
+  ## Files
+
+  `files` contains templates for the all the files to be
+  installed into the target directory.
+
+  The `__name__` token is subtituted with the dasherized
+  entity name at install time. For example, when the user
+  invokes `ember generate controller foo` then `__name__` becomes
+  `foo`. When the `--pod` flag is used, for example `ember
+  generate controller foo --pod` then `__name__` becomes
+  `controller`.
+
+  The `__path__` token is substituted with the blueprint
+  name at install time. For example, when the user invokes
+  `ember generate controller foo` then `__path__` becomes
+  `controller`. When the `--pod` flag is used, for example
+  `ember generate controller foo --pod` then `__path__`
+  becomes `foo` (or `<podModulePrefix>/foo` if the
+  podModulePrefix is defined). This token is primarily for
+  pod support, and is only necessary if the blueprint can be
+  used in pod structure. If the blueprint does not require pod
+  support, simply use the blueprint name instead of the
+  `__path__` token.
+
+  The `__test__` token is substituted with the dasherized
+  entity name and appended with `-test` at install time.
+  This token is primarily for pod support and only necessary
+  if the blueprint requires support for a pod structure. If
+  the blueprint does not require pod support, simply use the
+  `__name__` token instead.
+
+  ## Template Variables (AKA Locals)
+
+  Variables can be inserted into templates with
+  `<%= someVariableName %>`.
+
+  For example, the built-in `util` blueprint
+  `files/app/utils/__name__.js` looks like this:
+
+  ```js
+  export default function <%= camelizedModuleName %>() {
+    return true;
+  }
+  ```
+
+  `<%= camelizedModuleName %>` is replaced with the real
+  value at install time.
+
+  The following template variables are provided by default:
+
+  - `dasherizedPackageName`
+  - `classifiedPackageName`
+  - `dasherizedModuleName`
+  - `classifiedModuleName`
+  - `camelizedModuleName`
+
+  `packageName` is the project name as found in the project's
+  `package.json`.
+
+  `moduleName` is the name of the entity being generated.
+
+  The mechanism for providing custom template variables is
+  described below.
+
+  ## Index.js
+
+  Custom installation and uninstallation behavior can be added
+  by overriding the hooks documented below. `index.js` should
+  export a plain object, which will extend the prototype of the
+  `Blueprint` class. If needed, the original `Blueprint` prototype
+  can be accessed through the `_super` property.
+
+  ```js
+  module.exports = {
+    locals(options) {
+      // Return custom template variables here.
+      return {};
+    },
+
+    normalizeEntityName(entityName) {
+      // Normalize and validate entity name here.
+      return entityName;
+    },
+
+    fileMapTokens(options) {
+      // Return custom tokens to be replaced in your files
+      return {
+        __token__(options){
+          // logic to determine value goes here
+          return 'value';
+        }
+      }
+    },
+
+    filesPath(options) {
+      return path.join(this.path, 'files');
+    },
+
+    beforeInstall(options) {},
+    afterInstall(options) {},
+    beforeUninstall(options) {},
+    afterUninstall(options) {}
+
+  };
+  ```
+
+  ## Blueprint Hooks
+
+  ### beforeInstall & beforeUninstall
+
+  Called before any of the template files are processed and receives
+  the `options` and `locals` hashes as parameters. Typically used for
+  validating any additional command line options or for any asynchronous
+  setup that is needed.   As an example, the `controller` blueprint validates
+  its `--type` option in this hook.  If you need to run any asynchronous code,
+  wrap it in a promise and return that promise from these hooks.  This will
+  ensure that your code is executed correctly.
+
+  ### afterInstall & afterUninstall
+
+  The `afterInstall` and `afterUninstall` hooks receives the same
+  arguments as `locals`. Use it to perform any custom work after the
+  files are processed. For example, the built-in `route` blueprint
+  uses these hooks to add and remove relevant route declarations in
+  `app/router.js`.
+
+  ### Overriding Install
+
+  If you don't want your blueprint to install the contents of
+  `files` you can override the `install` method. It receives the
+  same `options` object described above and must return a promise.
+  See the built-in `resource` blueprint for an example of this.
+
+  @class Blueprint
+  @constructor
+  @extends CoreObject
+  @param {String} [blueprintPath]
+  @param {Object} [blueprintOptions]
+*/
+let Blueprint = CoreObject.extend({
+  availableOptions: [],
+  anonymousOptions: ['name'],
+
+  _printableProperties: ['name', 'description', 'availableOptions', 'anonymousOptions', 'overridden'],
+
+  /**
+    Indicates whether or not a blueprint is a candidate for automatic transpilation from TS to JS.
+    This property could be false in the case that the blueprint is written in JS and is not intended
+    to work with TS at all, OR in the case that the blueprint is written in TS and the author does
+    not intend to support transpilation to JS.
+
+    @public
+    @property shouldTransformTypeScript
+    @type Boolean
+  */
+  shouldTransformTypeScript: false,
+
+  init(blueprintPath, blueprintOptions) {
+    this._super();
+
+    this.path = blueprintPath;
+    this.name = blueprintOptions?.name ?? path.basename(blueprintPath);
+
+    this._processOptions(blueprintOptions);
+  },
+
+  /**
+    Process the options object coming from either
+    the `init`, `install` or `uninstall` hook.
+
+    @private
+    @method _processOptions
+    @param {Object} options
+  */
+  _processOptions(options = {}) {
+    this.options = options;
+    this.dryRun = options.dryRun;
+    this.pod = options.pod;
+    this.project = options.project;
+    this.ui = options.ui;
+  },
+
+  /**
+    Hook to specify the path to the blueprint's files. By default this is
+    `path.join(this.path, 'files)`.
+
+    This can be used to customize which set of files to install based on options
+    or environmental variables. It defaults to the `files` directory within the
+    blueprint's folder.
+
+    @public
+    @method filesPath
+    @param {Object} options
+    @return {String} Path to the blueprints files directory.
+  */
+  filesPath(/* options */) {
+    return path.join(this.path, 'files');
+  },
+
+  /**
+    Used to retrieve files for blueprint.
+
+    @public
+    @method files
+    @param {Object} options
+    @return {Array} Contents of the blueprint's files directory
+  */
+  files(/* options */) {
+    if (this._files) {
+      return this._files;
+    }
+
+    let filesPath = this.filesPath(this.options);
+    if (Blueprint._existsSync(filesPath)) {
+      this._files = walkSync(filesPath);
+    } else {
+      this._files = [];
+    }
+
+    return this._files;
+  },
+
+  /**
+    @method srcPath
+    @param {String} file
+    @return {String} Resolved path to the file
+  */
+  srcPath(file) {
+    return path.resolve(this.filesPath(this.options), file);
+  },
+
+  /**
+    Hook for normalizing entity name
+
+    Use the `normalizeEntityName` hook to add custom normalization and
+    validation of the provided entity name. The default hook does not
+    make any changes to the entity name, but makes sure an entity name
+    is present and that it doesn't have a trailing slash.
+
+    This hook receives the entity name as its first argument. The string
+    returned by this hook will be used as the new entity name.
+
+    @public
+    @method normalizeEntityName
+    @param {String} entityName
+    @return {null}
+  */
+  normalizeEntityName(entityName) {
+    return normalizeEntityName(entityName);
+  },
+
+  /**
+    Write a status and message to the UI
+    @private
+    @method _writeStatusToUI
+    @param {Function} chalkColor
+    @param {String} keyword
+    @param {String} message
+  */
+  _writeStatusToUI(chalkColor, keyword, message) {
+    if (this.ui) {
+      this.ui.writeLine(`  ${chalkColor(keyword)} ${message}`);
+    }
+  },
+
+  /**
+    @private
+    @method _writeFile
+    @param {Object} info
+    @return {Promise}
+  */
+  async _writeFile(info) {
+    if (!this.dryRun) {
+      return fs.outputFile(info.outputPath, await info.render());
+    }
+  },
+
+  /**
+    Actions lookup
+    @private
+    @property _actions
+    @type Object
+  */
+  _actions: {
+    write(info) {
+      this._writeStatusToUI(chalk.green, 'create', info.displayPath);
+      return this._writeFile(info);
+    },
+    skip(info) {
+      let label = 'skip';
+
+      if (info.resolution === 'identical') {
+        label = 'identical';
+      }
+
+      this._writeStatusToUI(chalk.yellow, label, info.displayPath);
+    },
+
+    overwrite(info) {
+      this._writeStatusToUI(chalk.yellow, 'overwrite', info.displayPath);
+      return this._writeFile(info);
+    },
+
+    edit(info) {
+      this._writeStatusToUI(chalk.green, 'edited', info.displayPath);
+    },
+
+    remove(info) {
+      this._writeStatusToUI(chalk.red, 'remove', info.displayPath);
+      if (!this.dryRun) {
+        return cleanRemove(info);
+      }
+    },
+  },
+
+  /**
+    Calls an action.
+    @private
+    @method _commit
+    @param {Object} result
+    @return {Promise}
+    @throws {Error} Action doesn't exist.
+  */
+  _commit(result) {
+    let action = this._actions[result.action];
+
+    if (action) {
+      return action.call(this, result);
+    } else {
+      throw new Error(`Tried to call action "${result.action}" but it does not exist`);
+    }
+  },
+
+  /**
+    Prints warning for pod unsupported.
+    @private
+    @method _checkForPod
+  */
+  _checkForPod(verbose) {
+    if (!this.hasPathToken && this.pod && verbose) {
+      this.ui.writeLine(
+        chalk.yellow(
+          'You specified the pod flag, but this' +
+            ' blueprint does not support pod structure. It will be generated with' +
+            ' the default structure.'
+        )
+      );
+    }
+  },
+
+  /**
+    @private
+    @method _normalizeEntityName
+    @param {Object} entity
+  */
+  _normalizeEntityName(entity) {
+    if (entity) {
+      entity.name = this.normalizeEntityName(entity.name);
+    }
+  },
+
+  /**
+    @private
+    @method _checkInRepoAddonExists
+    @param {Object} options
+  */
+  _checkInRepoAddonExists(options) {
+    let addon;
+
+    if (options.inRepoAddon) {
+      addon = findAddonByName(this.project, options.inRepoAddon);
+
+      if (!addon) {
+        throw new SilentError(
+          `You specified the 'in-repo-addon' flag, but the ` +
+            `in-repo-addon '${options.inRepoAddon}' does not exist. Please check the name and try again.`
+        );
+      }
+    }
+
+    if (options.in) {
+      if (!ensureTargetDirIsAddon(options.in)) {
+        throw new SilentError(
+          `You specified the 'in' flag, but the ` +
+            `in repo addon '${options.in}' does not exist. Please check the name and try again.`
+        );
+      }
+    }
+  },
+
+  /**
+    @private
+    @method _process
+    @param {Object} options
+    @param {Function} beforeHook
+    @param {Function} process
+    @param {Function} afterHook
+  */
+  async _process(options, beforeHook, process, afterHook) {
+    let intoDir = options.target;
+
+    let locals = await this._locals(options);
+
+    // run beforeInstall/beforeUninstall userland hooks
+    await beforeHook.call(this, options, locals);
+
+    // gather fileInfos to be processed
+    let fileInfos = await process.call(this, intoDir, locals, options);
+
+    // commit changes for each FileInfo (with prompting as needed)
+    await Promise.all(fileInfos.map((info) => this._commit(info)));
+
+    // run afterInstall/afterUninstall userland hooks
+    await afterHook.call(this, options);
+  },
+
+  /**
+    @private
+    @method shouldConvertToJS
+    @param {Object} options
+    @param {FileInfo} fileInfo
+    @return {Boolean}
+  */
+  shouldConvertToJS(options, fileInfo) {
+    // If this isn't turned on, it doesn't matter what else was passed, we're not touching it.
+    if (!this.shouldTransformTypeScript) {
+      return false;
+    }
+
+    // If the blueprint isn't a TS file to begin with, there's nothing to convert.
+    if (!isTypeScriptFile(fileInfo.outputPath)) {
+      return false;
+    }
+
+    // Indicates when the user explicitly passed either `--typescript` or `--no-typescript` as opposed
+    // to not passing a flag at all and allowing for default behavior
+    const userExplicitlySelectedTypeScriptStatus = options.typescript !== undefined;
+
+    // Indicates when the user has asked for TypeScript either globally (by setting
+    // `isTypeScriptProject` to true) or locally (by passing the `--typescript` flag when they
+    // invoked the generator). Although ember-cli merges `.ember-cli` and all of the flag values into
+    // one object, we thought the DX would be improved by differentiating between what is intended
+    // to be global vs. local config.
+    const shouldUseTypeScript = userExplicitlySelectedTypeScriptStatus
+      ? options.typescript
+      : options.isTypeScriptProject;
+
+    // if the user wants TS output and we have a TS file available, we do *not* want to downlevel to JS
+    if (shouldUseTypeScript) {
+      return false;
+    }
+
+    return true;
+  },
+
+  /**
+    @private
+    @method convertToJS
+    @param {FileInfo} fileInfo
+    @return {Promise}
+  */
+  async convertToJS(fileInfo) {
+    let rendered = await fileInfo.render();
+
+    fileInfo.rendered = await this.removeTypes(path.extname(fileInfo.displayPath), rendered);
+    fileInfo.displayPath = replaceTypeScriptExtension(fileInfo.displayPath);
+    fileInfo.outputPath = replaceTypeScriptExtension(fileInfo.outputPath);
+
+    return fileInfo;
+  },
+
+  /**
+    @private
+    @method removeTypes
+    @param {string} extension
+    @param {string} code
+    @return {Promise}
+  */
+  async removeTypes(extension, code) {
+    const { removeTypes } = require('babel-remove-types');
+
+    if (extension === '.gts') {
+      const { Preprocessor } = require('content-tag');
+      const preprocessor = new Preprocessor();
+      // Strip template tags
+      const replacementClassMember = (i) => `template = __TEMPLATE_TAG_${i}__;`;
+      const replacementExpression = (i) => `__TEMPLATE_TAG_${i}__`;
+      const templateTagMatches = preprocessor.parse(code);
+      let strippedCode = code;
+      for (let i = 0; i < templateTagMatches.length; i++) {
+        const match = templateTagMatches[i];
+        const templateTag = substringBytes(code, match.range.startByte, match.range.endByte);
+        if (match.type === 'class-member') {
+          strippedCode = strippedCode.replace(templateTag, replacementClassMember(i));
+        } else {
+          strippedCode = strippedCode.replace(templateTag, replacementExpression(i));
+        }
+      }
+
+      // Remove types
+      const transformed = await removeTypes(strippedCode);
+
+      // Readd stripped template tags
+      let transformedWithTemplateTag = transformed;
+      for (let i = 0; i < templateTagMatches.length; i++) {
+        const match = templateTagMatches[i];
+        const templateTag = substringBytes(code, match.range.startByte, match.range.endByte);
+        if (match.type === 'class-member') {
+          transformedWithTemplateTag = transformedWithTemplateTag.replace(replacementClassMember(i), templateTag);
+        } else {
+          // babel-remove-types uses prettier under the hood, and adds trailing `;` where allowed,
+          // so we need to take that into account when restoring the template tags:
+          transformedWithTemplateTag = transformedWithTemplateTag.replace(`${replacementExpression(i)};`, templateTag);
+          transformedWithTemplateTag = transformedWithTemplateTag.replace(replacementExpression(i), templateTag);
+        }
+      }
+
+      return transformedWithTemplateTag;
+    }
+
+    return await removeTypes(code);
+  },
+
+  /**
+    @method install
+    @param {Object} options
+    @return {Promise}
+  */
+  install(options) {
+    this._processOptions(options);
+
+    this.hasPathToken = hasPathToken(this.files(this.options));
+
+    this.ui.writeLine(`installing ${this.name}`);
+
+    if (this.dryRun) {
+      this.ui.writeLine(chalk.yellow('You specified the `dry-run` flag, so no changes will be written.'));
+    }
+
+    this._normalizeEntityName(options.entity);
+    this._checkForPod(options.verbose);
+    this._checkInRepoAddonExists(options);
+
+    logger.info('START: processing blueprint: `%s`', this.name);
+    let start = new Date();
+    return this._process(options, this.beforeInstall, this.processFiles, this.afterInstall).finally(() =>
+      logger.info('END: processing blueprint: `%s` in (%dms)', this.name, new Date() - start)
+    );
+  },
+
+  /**
+    @method uninstall
+    @param {Object} options
+    @return {Promise}
+  */
+  uninstall(options) {
+    this._processOptions(options);
+
+    this.hasPathToken = hasPathToken(this.files(this.options));
+
+    this.ui.writeLine(`uninstalling ${this.name}`);
+
+    if (this.dryRun) {
+      this.ui.writeLine(chalk.yellow('You specified the `dry-run` flag, so no files will be deleted.'));
+    }
+
+    this._normalizeEntityName(options.entity);
+    this._checkForPod(options.verbose);
+
+    return this._process(options, this.beforeUninstall, this.processFilesForUninstall, this.afterUninstall);
+  },
+
+  /**
+    Hook for running operations before install.
+    @method beforeInstall
+    @return {Promise|null}
+  */
+  beforeInstall() {},
+
+  /**
+    Hook for running operations after install.
+    @method afterInstall
+    @return {Promise|null}
+  */
+  afterInstall() {},
+
+  /**
+    Hook for running operations before uninstall.
+    @method beforeUninstall
+    @return {Promise|null}
+  */
+  beforeUninstall() {},
+
+  /**
+    Hook for running operations after uninstall.
+    @method afterUninstall
+    @return {Promise|null}
+  */
+  afterUninstall() {},
+
+  filesToRemove: [],
+
+  /**
+    Hook for adding custom template variables.
+
+    When the following is called on the command line:
+
+    ```sh
+    ember generate controller foo --type=array --dry-run isAdmin:true
+    ```
+
+    The object passed to `locals` looks like this:
+
+    ```js
+    {
+      entity: {
+        name: 'foo',
+        options: {
+          isAdmin: true
+        }
+      },
+      dryRun: true
+      type: "array"
+      // more keys
+    }
+    ```
+
+    This hook must return an object or a Promise which resolves to an object.
+    The resolved object will be merged with the aforementioned default locals.
+
+    @public
+    @method locals
+    @param {Object} options General and entity-specific options
+    @return {Object|Promise|null}
+  */
+  locals(/* options */) {},
+
+  /**
+    Hook to add additional or override existing fileMap tokens.
+
+    Use `fileMapTokens` to add custom fileMap tokens for use
+    in the `mapFile` method. The hook must return an object in the
+    following pattern:
+
+    ```js
+    {
+      __token__(options){
+        // logic to determine value goes here
+        return 'value';
+      }
+    }
+    ```
+
+    It will be merged with the default `fileMapTokens`, and can be used
+    to override any of the default tokens.
+
+    Tokens are used in the files folder (see `files`), and get replaced with
+    values when the `mapFile` method is called.
+
+    @public
+    @method fileMapTokens
+    @return {Object|null}
+  */
+  fileMapTokens() {},
+
+  /**
+    @private
+    @method _fileMapTokens
+    @param {Object} options
+    @return {Object}
+  */
+  _fileMapTokens(options) {
+    let { project } = this;
+    let standardTokens = {
+      __name__(options) {
+        if (options.pod && options.hasPathToken) {
+          return options.blueprintName;
+        }
+        return options.dasherizedModuleName;
+      },
+      __path__(options) {
+        let blueprintName = options.blueprintName;
+
+        if (/-test/.test(blueprintName)) {
+          blueprintName = options.blueprintName.slice(0, options.blueprintName.indexOf('-test'));
+        }
+        if (options.pod && options.hasPathToken) {
+          return path.join(options.podPath, options.dasherizedModuleName);
+        }
+        return pluralize(blueprintName);
+      },
+      __root__(options) {
+        if (options.inRepoAddon) {
+          let addon = findAddonByName(project, options.inRepoAddon);
+          let relativeAddonPath = path.relative(project.root, addon.root);
+          return path.join(relativeAddonPath, 'addon');
+        }
+        if (options.in) {
+          let relativeAddonPath = path.relative(project.root, options.in);
+          return path.join(relativeAddonPath, 'addon');
+        }
+        if (options.inDummy) {
+          return path.join('tests', 'dummy', 'app');
+        }
+        if (options.inAddon) {
+          return 'addon';
+        }
+        return 'app';
+      },
+      __test__(options) {
+        if (options.pod && options.hasPathToken) {
+          return options.blueprintName;
+        }
+        return `${options.dasherizedModuleName}-test`;
+      },
+    };
+
+    let customTokens = this.fileMapTokens(options) || options.fileMapTokens || {};
+    return merge(standardTokens, customTokens);
+  },
+
+  /**
+    Used to generate fileMap tokens for mapFile.
+
+    @method generateFileMap
+    @param {Object} fileMapVariables
+    @return {Object}
+  */
+  generateFileMap(fileMapVariables) {
+    let tokens = this._fileMapTokens(fileMapVariables);
+    let fileMapValues = Object.values(tokens);
+    let tokenValues = fileMapValues.map((token) => token(fileMapVariables));
+    let tokenKeys = Object.keys(tokens);
+    return zipObject(tokenKeys, tokenValues);
+  },
+
+  /**
+    @method buildFileInfo
+    @param {Function} destPath
+    @param {Object} templateVariables
+    @param {String} file
+    @param {Object} options may be used when buildFileInfo is customized in a blueprint
+    @return {FileInfo | null}
+  */
+  buildFileInfo(intoDir, templateVariables, file /*, options */) {
+    let mappedPath = this.mapFile(file, templateVariables);
+
+    return new FileInfo({
+      action: 'write',
+      outputBasePath: path.normalize(intoDir),
+      outputPath: path.join(intoDir, mappedPath),
+      displayPath: path.normalize(mappedPath),
+      inputPath: this.srcPath(file),
+      templateVariables,
+      ui: this.ui,
+    });
+  },
+
+  /**
+    @method isUpdate
+    @return {Boolean}
+  */
+  isUpdate() {
+    if (this.project && this.project.isEmberCLIProject) {
+      return this.project.isEmberCLIProject();
+    }
+  },
+
+  /**
+    @private
+    @method _getFileInfos
+    @param {Array} files
+    @param {String} intoDir
+    @param {Object} templateVariables
+    @param {Object} options
+    @return {Array} file infos
+  */
+  _getFileInfos(files, intoDir, templateVariables, options) {
+    return files
+      .map((file) => this.buildFileInfo.call(this, intoDir, templateVariables, file, options))
+      .filter(Boolean);
+  },
+
+  /**
+    Add update files to ignored files or reset them
+    @private
+    @method _ignoreUpdateFiles
+  */
+  _ignoreUpdateFiles() {
+    if (this.isUpdate()) {
+      Blueprint.ignoredFiles = Blueprint.ignoredFiles.concat(Blueprint.ignoredUpdateFiles);
+    } else {
+      Blueprint.ignoredFiles = initialIgnoredFiles;
+    }
+  },
+
+  /**
+    @private
+    @method _getFilesForInstall
+    @param {Array} targetFiles
+    @return {Array} files
+  */
+  _getFilesForInstall(targetFiles) {
+    let files = this.files(this.options);
+
+    // if we've defined targetFiles, get file info on ones that match
+    return (targetFiles && targetFiles.length > 0 && intersection(files, targetFiles)) || files;
+  },
+
+  /**
+    @private
+    @method _checkForNoMatch
+    @param {Array} fileInfos
+    @param {String} rawArgs
+  */
+  _checkForNoMatch(fileInfos, rawArgs) {
+    if (fileInfos.filter(isFilePath).length < 1 && rawArgs) {
+      this.ui.writeLine(
+        chalk.yellow(`The globPattern "${rawArgs}" ` + `did not match any files, so no file updates will be made.`)
+      );
+    }
+  },
+
+  /**
+    @method processFiles
+    @param {String} intoDir
+    @param {Object} templateVariables
+    @param {Object} options
+    @return {Promise<FileInfo[]>}
+  */
+  processFiles(intoDir, templateVariables, options) {
+    let files = this._getFilesForInstall(templateVariables.targetFiles);
+    let fileInfos = this._getFileInfos(files, intoDir, templateVariables, options);
+    this._checkForNoMatch(fileInfos, templateVariables.rawArgs);
+
+    this._ignoreUpdateFiles();
+
+    let fileInfosToRemove = this._getFileInfos(this.filesToRemove, intoDir, templateVariables);
+
+    fileInfosToRemove = finishProcessingForUninstall(fileInfosToRemove);
+
+    return Promise.all(fileInfos.filter(isValidFile).map(prepareConfirm))
+      .then(finishProcessingForInstall)
+      .then((fileInfos) => {
+        return Promise.all(
+          fileInfos.map((info) => {
+            if (this.shouldConvertToJS(this.options, info)) {
+              return this.convertToJS(info);
+            }
+
+            return info;
+          })
+        );
+      })
+      .then((fileInfos) => fileInfos.concat(fileInfosToRemove));
+  },
+
+  /**
+    @method processFilesForUninstall
+    @param {String} intoDir
+    @param {Object} templateVariables
+  */
+  processFilesForUninstall(intoDir, templateVariables) {
+    let fileInfos = this._getFileInfos(this.files(this.options), intoDir, templateVariables);
+
+    this._ignoreUpdateFiles();
+
+    fileInfos = fileInfos.filter(isValidFile).reduce((acc, info) => {
+      // if it's possible that this blueprint could have produced either typescript OR javascript, we have to do some
+      // work to figure out which files to delete.
+      if (this.shouldTransformTypeScript) {
+        if (this.options.typescript === true) {
+          // if the user explicitly passed `--typescript`, we only want to delete TS files, so we stick with the existing
+          // info object since it will contain a .ts outputPath (since we know this blueprint is authored in TS because
+          // of our check above)
+          acc.push(info);
+          return acc;
+        }
+
+        const jsInfo = new FileInfo({
+          ...info,
+          outputPath: replaceTypeScriptExtension(info.outputPath),
+          displayPath: replaceTypeScriptExtension(info.displayPath),
+        });
+
+        if (this.options.typescript === false) {
+          // if the user explicitly passed `--no-typescript`, we only want to delete JS file, so we return our newly
+          // created jsInfo object since it contains the javascript version of the output path.
+          acc.push(jsInfo);
+          return acc;
+        }
+
+        if (this.options.typescript === undefined) {
+          // if the user didn't specify one way or the other, then both the JS and TS paths are possibilities, so we add
+          // both of them to the list. `finishProcessingForUninstall` will actually look to see which of them exists and
+          // delete whatever it finds.
+          acc.push(info, jsInfo);
+          return acc;
+        }
+      }
+
+      acc.push(info);
+      return acc;
+    }, []);
+
+    return finishProcessingForUninstall(fileInfos);
+  },
+
+  /**
+    @method mapFile
+    @param {String} file
+    @param locals
+    @return {String}
+  */
+  mapFile(file, locals) {
+    let pattern, i;
+    let fileMap = locals.fileMap || { __name__: locals.dasherizedModuleName };
+    file = Blueprint.renamedFiles[file] || file;
+    for (i in fileMap) {
+      pattern = new RegExp(i, 'g');
+      file = file.replace(pattern, fileMap[i]);
+    }
+    return file;
+  },
+
+  /**
+    Looks for a __root__ token in the files folder. Must be present for
+    the blueprint to support addon tokens. The `server`, `blueprints`, and `test`
+
+    @private
+    @method supportsAddon
+    @return {Boolean}
+  */
+  supportsAddon() {
+    return /__root__/.test(this.files(this.options).join());
+  },
+
+  /**
+    @private
+    @method _generateFileMapVariables
+    @param {String} moduleName
+    @param locals
+    @param {Object} options
+    @return {Object}
+  */
+  _generateFileMapVariables(moduleName, locals, options) {
+    let originBlueprintName = options.originBlueprintName || this.name;
+    let podModulePrefix = this.project.config().podModulePrefix || '';
+    let podPath = podModulePrefix.substr(podModulePrefix.lastIndexOf('/') + 1);
+    let inAddon = this.project.isEmberCLIAddon() || !!options.inRepoAddon;
+    let inDummy = this.project.isEmberCLIAddon() ? options.dummy : false;
+
+    return {
+      pod: this.pod,
+      podPath,
+      hasPathToken: this.hasPathToken,
+      inAddon,
+      inRepoAddon: options.inRepoAddon,
+      in: options.in,
+      inDummy,
+      blueprintName: this.name,
+      originBlueprintName,
+      dasherizedModuleName: stringUtils.dasherize(moduleName),
+      locals,
+    };
+  },
+
+  /**
+    @private
+    @method _locals
+    @param {Object} options
+    @return {Object}
+  */
+  _locals(options) {
+    let packageName = options.project.name();
+    let moduleName = (options.entity && options.entity.name) || packageName;
+    let sanitizedModuleName = moduleName.replace(/\//g, '-');
+
+    return new Promise((resolve) => {
+      resolve(this.locals(options));
+    }).then((customLocals) => {
+      let fileMapVariables = this._generateFileMapVariables(moduleName, customLocals, options);
+      let fileMap = this.generateFileMap(fileMapVariables);
+      let standardLocals = {
+        dasherizedPackageName: stringUtils.dasherize(packageName),
+        classifiedPackageName: stringUtils.classify(packageName),
+        dasherizedModuleName: stringUtils.dasherize(moduleName),
+        classifiedModuleName: stringUtils.classify(sanitizedModuleName),
+        camelizedModuleName: stringUtils.camelize(sanitizedModuleName),
+        decamelizedModuleName: stringUtils.decamelize(sanitizedModuleName),
+        fileMap,
+        hasPathToken: this.hasPathToken,
+        targetFiles: options.targetFiles,
+        rawArgs: options.rawArgs,
+      };
+
+      return merge({}, standardLocals, customLocals);
+    });
+  },
+
+  /**
+    Used to add a package to the project's `package.json`.
+
+    Generally, this would be done from the `afterInstall` hook, to
+    ensure that a package that is required by a given blueprint is
+    available.
+
+    @method addPackageToProject
+    @param {String} packageName
+    @param {String} target
+    @return {Promise}
+  */
+  addPackageToProject(packageName, target) {
+    let packageObject = { name: packageName };
+
+    if (target) {
+      packageObject.target = target;
+    }
+
+    return this.addPackagesToProject([packageObject]);
+  },
+
+  /**
+    Used to add multiple packages to the project's `package.json`.
+
+    Generally, this would be done from the `afterInstall` hook, to
+    ensure that a package that is required by a given blueprint is
+    available.
+
+    Expects each array item to be an object with a `name`.  Each object
+    may optionally have a `target` to specify a specific version.
+
+    @method addPackagesToProject
+    @param {Array} packages
+    @return {Promise}
+
+    @example
+    ```js
+    this.addPackagesToProject([
+      { name: 'lodash' },
+      { name: 'moment', target: '^2.17.0' },
+    ]);
+    ```
+  */
+  addPackagesToProject(packages) {
+    let task = this.taskFor('npm-install');
+    let installText = packages.length > 1 ? 'install packages' : 'install package';
+    let packageNames = [];
+    let packageArray = [];
+
+    for (let i = 0; i < packages.length; i++) {
+      packageNames.push(packages[i].name);
+
+      let packageNameAndVersion = packages[i].name;
+
+      if (packages[i].target) {
+        packageNameAndVersion += `@${packages[i].target}`;
+      }
+
+      packageArray.push(packageNameAndVersion);
+    }
+
+    this._writeStatusToUI(chalk.green, installText, packageNames.join(', '));
+
+    return task.run({
+      'save-dev': true,
+      verbose: false,
+      packages: packageArray,
+    });
+  },
+
+  /**
+    Used to remove a package from the project's `package.json`.
+
+    Generally, this would be done from the `afterInstall` hook, to
+    ensure that any package conflicts can be resolved before the
+    addon is used.
+
+    @method removePackageFromProject
+    @param {String} packageName
+    @return {Promise}
+  */
+  removePackageFromProject(packageName) {
+    let packageObject = { name: packageName };
+
+    return this.removePackagesFromProject([packageObject]);
+  },
+
+  /**
+    Used to remove multiple packages from the project's `package.json`.
+
+    Generally, this would be done from the `afterInstall` hook, to
+    ensure that any package conflicts can be resolved before the
+    addon is used.
+
+    Expects each array item to be an object with a `name` property.
+
+    @method removePackagesFromProject
+    @param {Array} packages
+    @return {Promise}
+  */
+  removePackagesFromProject(packages) {
+    let task = this.taskFor('npm-uninstall');
+    let installText = packages.length > 1 ? 'uninstall packages' : 'uninstall package';
+    let packageNames = [];
+
+    let projectDependencies = this.project.dependencies();
+
+    for (let i = 0; i < packages.length; i++) {
+      let packageName = packages[i].name;
+      if (packageName in projectDependencies) {
+        packageNames.push(packageName);
+      }
+    }
+
+    if (packageNames.length === 0) {
+      this._writeStatusToUI(chalk.yellow, 'remove', 'Skipping uninstall because no matching package is installed.');
+      return Promise.resolve();
+    }
+
+    this._writeStatusToUI(chalk.green, installText, packageNames.join(', '));
+
+    return task.run({
+      'save-dev': true,
+      verbose: false,
+      packages: packageNames,
+    });
+  },
+
+  /**
+    Used to add an addon to the project's `package.json` and run it's
+    `defaultBlueprint` if it provides one.
+
+    Generally, this would be done from the `afterInstall` hook, to
+    ensure that a package that is required by a given blueprint is
+    available.
+
+    @method addAddonToProject
+    @param {Object} options
+    @return {Promise}
+  */
+  addAddonToProject(options) {
+    return this.addAddonsToProject({
+      packages: [options],
+      extraArgs: options.extraArgs || {},
+      blueprintOptions: options.blueprintOptions || {},
+    });
+  },
+
+  /**
+    Used to add multiple addons to the project's `package.json` and run their
+    `defaultBlueprint` if they provide one.
+
+    Generally, this would be done from the `afterInstall` hook, to
+    ensure that a package that is required by a given blueprint is
+    available.
+
+    @method addAddonsToProject
+    @param {Object} options
+    @return {Promise}
+  */
+  addAddonsToProject(options) {
+    let taskOptions = {
+      packages: [],
+      extraArgs: options.extraArgs || [],
+      blueprintOptions: options.blueprintOptions || {},
+    };
+
+    let packages = options.packages;
+    if (packages && packages.length) {
+      taskOptions.packages = packages.map((pkg) => {
+        if (typeof pkg === 'string') {
+          return pkg;
+        }
+
+        if (!pkg.name) {
+          throw new SilentError('You must provide a package `name` to addAddonsToProject');
+        }
+
+        if (pkg.target) {
+          pkg.name += `@${pkg.target}`;
+        }
+
+        return pkg.name;
+      });
+    } else {
+      throw new SilentError('You must provide package to addAddonsToProject');
+    }
+
+    let installText = packages.length > 1 ? 'install addons' : 'install addon';
+    this._writeStatusToUI(chalk.green, installText, taskOptions['packages'].join(', '));
+
+    let previousCwd;
+    if (!this.project.isEmberCLIProject()) {
+      // The install task adds dependencies based on the current working directory.
+      // But in case we created the new project by calling the blueprint with a custom target directory (options.target),
+      // the current directory will *not* be the one the project is created in, so we must adjust this here.
+      previousCwd = process.cwd();
+      process.chdir(options.blueprintOptions.target);
+    }
+
+    let result = this.taskFor('addon-install').run(taskOptions);
+    if (previousCwd) {
+      return result.then(() => process.chdir(previousCwd));
+    }
+
+    return result;
+  },
+
+  /**
+    Used to retrieve a task with the given name. Passes the new task
+    the standard information available (like `ui`, `project`, etc).
+
+    @method taskFor
+    @param dasherizedName
+    @public
+  */
+  taskFor(dasherizedName) {
+    const Task = require(`../tasks/${dasherizedName}`);
+
+    return new Task({
+      ui: this.ui,
+      project: this.project,
+    });
+  },
+
+  /**
+    Inserts the given content into a file. If the `contentsToInsert` string is already
+    present in the current contents, the file will not be changed unless `force` option
+    is passed.
+
+    If `options.before` is specified, `contentsToInsert` will be inserted before
+    the first instance of that string.  If `options.after` is specified, the
+    contents will be inserted after the first instance of that string.
+    If the string specified by options.before or options.after is not in the file,
+    no change will be made.
+
+    If neither `options.before` nor `options.after` are present, `contentsToInsert`
+    will be inserted at the end of the file.
+
+    Example:
+    ```
+    // app/router.js
+    Router.map(function () {
+    });
+    ```
+
+    ```
+    insertIntoFile('app/router.js', '  this.route("admin");', {
+      after: 'Router.map(function () {' + EOL
+    }).then(function() {
+      // file has been inserted into!
+    });
+
+
+    ```
+
+    ```
+    // app/router.js
+    Router.map(function () {
+      this.route("admin");
+    });
+    ```
+
+    @method insertIntoFile
+    @param {String} pathRelativeToProjectRoot
+    @param {String} contentsToInsert
+    @param {Object} providedOptions
+    @return {Promise}
+  */
+  insertIntoFile(pathRelativeToProjectRoot, contentsToInsert, providedOptions) {
+    let fullPath = path.join(this.project.root, pathRelativeToProjectRoot);
+    return insertIntoFile(fullPath, contentsToInsert, providedOptions);
+  },
+
+  _printCommand: printCommand,
+
+  printBasicHelp(verbose) {
+    let initialMargin = '      ';
+    let output = initialMargin;
+    if (this.overridden) {
+      output += chalk.grey(`(overridden) ${this.name}`);
+    } else {
+      output += this.name;
+
+      output += this._printCommand(initialMargin, true);
+
+      if (verbose) {
+        output += EOL + this.printDetailedHelp(this.availableOptions);
+      }
+    }
+
+    return output;
+  },
+
+  printDetailedHelp() {
+    let markdownColor = new MarkdownColor();
+    let filePath = getDetailedHelpPath(this.path);
+
+    if (Blueprint._existsSync(filePath)) {
+      return markdownColor.renderFile(filePath, { indent: '        ' });
+    }
+    return '';
+  },
+
+  getJson(verbose) {
+    let json = {};
+    this._printableProperties.forEach((key) => {
+      let value = this[key];
+      if (key === 'availableOptions') {
+        value = cloneDeep(value);
+        value.forEach((option) => {
+          if (typeof option.type === 'function') {
+            option.type = option.type.name;
+          }
+        });
+      }
+      json[key] = value;
+    });
+
+    if (verbose) {
+      let detailedHelp = this.printDetailedHelp(this.availableOptions);
+      if (detailedHelp) {
+        json.detailedHelp = detailedHelp;
+      }
+    }
+
+    return json;
+  },
+
+  /**
+    Used to retrieve a blueprint with the given name.
+
+    @method lookupBlueprint
+    @param {String} dasherizedName
+    @return {Blueprint}
+    @public
+  */
+  lookupBlueprint(dasherizedName) {
+    let projectPaths = this.project ? this.project.blueprintLookupPaths() : [];
+
+    return Blueprint.lookup(dasherizedName, {
+      paths: projectPaths,
+    });
+  },
+});
+
+const builtInBlueprints = new Map([
+  ['app', '@ember-tooling/classic-build-app-blueprint'],
+  ['addon', '@ember-tooling/classic-build-addon-blueprint'],
+  ['blueprint', '@ember-tooling/blueprint-blueprint'],
+]);
+
+/**
+  @static
+  @method lookup
+  @namespace Blueprint
+  @param {String} name
+  @param {Object} [options]
+  @param {Array} [options.paths] Extra paths to search for blueprints
+  @param {Boolean} [options.ignoreMissing] Throw a `SilentError` if a
+    matching Blueprint could not be found
+  @param {Object} [options.blueprintOptions] Options object that will be passed
+    along to the Blueprint instance on creation.
+  @return {Blueprint}
+*/
+Blueprint.lookup = function (name, options) {
+  options = options || {};
+
+  let lookupPaths = new Set(options.paths);
+
+  for (let path of options?.project?.blueprintLookupPaths() ?? []) {
+    lookupPaths.add(path);
+  }
+
+  for (let lookupPath of lookupPaths) {
+    let blueprintPath = path.resolve(lookupPath, name);
+
+    if (Blueprint._existsSync(blueprintPath)) {
+      return Blueprint.load(blueprintPath, options.blueprintOptions);
+    }
+  }
+
+  // Check if `name` itself is a path to a blueprint:
+  if (name.includes(path.sep)) {
+    let blueprintPath = path.resolve(name);
+
+    if (Blueprint._existsSync(blueprintPath)) {
+      return Blueprint.load(blueprintPath, options.blueprintOptions);
+    }
+  }
+
+  // Check for the built in blueprints
+  if (builtInBlueprints.has(name)) {
+    let blueprintPath = require.resolve(builtInBlueprints.get(name));
+
+    if (Blueprint._existsSync(blueprintPath)) {
+      return Blueprint.load(path.dirname(blueprintPath), options.blueprintOptions);
+    }
+  }
+
+  if (!options.ignoreMissing) {
+    throw new SilentError(`Unknown blueprint: ${name}`);
+  }
+};
+
+/**
+  Loads a blueprint from given path.
+  @static
+  @method load
+  @namespace Blueprint
+  @param {String} blueprintPath
+  @param {Object} [blueprintOptions]
+  @return {Blueprint} blueprint instance
+*/
+Blueprint.load = function (blueprintPath, blueprintOptions) {
+  if (fs.lstatSync(blueprintPath).isDirectory()) {
+    let Constructor = Blueprint;
+
+    let constructorPath = path.resolve(blueprintPath, 'index.js');
+    if (Blueprint._existsSync(constructorPath)) {
+      let blueprintModule = require(constructorPath);
+
+      if (blueprintModule.__esModule) {
+        blueprintModule = blueprintModule.default;
+      }
+
+      if (typeof blueprintModule === 'function') {
+        Constructor = blueprintModule;
+      } else {
+        Constructor = Blueprint.extend(blueprintModule);
+      }
+    }
+
+    return new Constructor(blueprintPath, blueprintOptions);
+  }
+};
+
+/**
+  @static
+  @method list
+  @namespace Blueprint
+  @param {Object} [options]
+  @param {Array} [options.paths] Extra paths to search for blueprints
+  @return {Array}
+*/
+Blueprint.list = function (options) {
+  options = options || {};
+
+  let lookupPaths = new Set(options.paths);
+
+  for (let path of options?.project?.blueprintLookupPaths() ?? []) {
+    lookupPaths.add(path);
+  }
+
+  let seen = [];
+
+  return Array.from(lookupPaths).map((lookupPath) => {
+    let source;
+    let packagePath = path.join(lookupPath, '../package.json');
+    if (Blueprint._existsSync(packagePath)) {
+      source = require(packagePath).name;
+    } else {
+      source = path.basename(path.join(lookupPath, '..'));
+    }
+
+    let blueprints = dir(lookupPath).map((blueprintPath) => {
+      let blueprint = Blueprint.load(blueprintPath);
+      if (blueprint) {
+        let name = blueprint.name;
+        blueprint.overridden = seen.includes(name);
+        seen.push(name);
+
+        return blueprint;
+      }
+    });
+
+    // if we're listing blueprints from ember-cli then we should add the built-in blueprints
+    if (source === 'ember-cli') {
+      for (let [blueprintName, blueprintPackage] of builtInBlueprints.entries()) {
+        let blueprint = Blueprint.load(path.dirname(require.resolve(blueprintPackage)), {
+          name: blueprintName,
+        });
+
+        let name = blueprintName;
+        blueprint.overridden = seen.includes(name);
+        seen.push(name);
+
+        blueprints.push(blueprint);
+      }
+    }
+
+    return {
+      source,
+      blueprints: sortBy(compact(blueprints), 'name'),
+    };
+  });
+};
+
+Blueprint._existsSync = function (path, parent) {
+  return fs.existsSync(path, parent);
+};
+
+Blueprint._readdirSync = function (path) {
+  return fs.readdirSync(path);
+};
+
+/**
+  Files that are renamed when installed into the target directory.
+  This allows including files in the blueprint that would have an effect
+  on another process, such as a file named `.gitignore`.
+
+  The keys are the filenames used in the files folder.
+  The values are the filenames used in the target directory.
+
+  @static
+  @property renamedFiles
+*/
+Blueprint.renamedFiles = {
+  gitignore: '.gitignore',
+};
+
+/**
+  @static
+  @property ignoredFiles
+*/
+Blueprint.ignoredFiles = initialIgnoredFiles;
+
+/**
+  @static
+  @property ignoredUpdateFiles
+*/
+Blueprint.ignoredUpdateFiles = ['.gitkeep', 'app.css', 'LICENSE.md'];
+
+/**
+  @private
+  @method prepareConfirm
+  @param {FileInfo} info
+  @return {Promise}
+*/
+function prepareConfirm(info) {
+  return info.checkForConflict().then((resolution) => {
+    info.resolution = resolution;
+    return info;
+  });
+}
+
+/**
+  @private
+  @method markIdenticalToBeSkipped
+  @param {FileInfo} info
+*/
+function markIdenticalToBeSkipped(info) {
+  if (info.resolution === 'identical') {
+    info.action = 'skip';
+  }
+}
+
+/**
+  @private
+  @method markToBeRemoved
+  @param {FileInfo} info
+*/
+function markToBeRemoved(info) {
+  info.action = 'remove';
+}
+
+/**
+  @private
+  @method gatherConfirmationMessages
+  @param {Array} collection
+  @param {FileInfo} info
+  @return {Array}
+*/
+function gatherConfirmationMessages(collection, info) {
+  if (info.resolution === 'confirm') {
+    collection.push(info.confirmOverwriteTask());
+  }
+  return collection;
+}
+
+/**
+  @private
+  @method isIgnored
+  @param {FileInfo} info
+  @return {Boolean}
+*/
+function isIgnored(info) {
+  let fn = info.inputPath;
+
+  return Blueprint.ignoredFiles.some((ignoredFile) => minimatch(fn, ignoredFile, { matchBase: true }));
+}
+
+/**
+  Looks for a __path__ token in the files folder. Must be present for
+  the blueprint to support pod tokens.
+
+  @private
+  @method hasPathToken
+  @param {files} files
+  @return {Boolean}
+*/
+function hasPathToken(files) {
+  return /__path__/.test(files.join());
+}
+
+function findAddonByName(addonOrProject, name) {
+  let addon = addonOrProject.addons.find((addon) => addon.name === name);
+
+  if (addon) {
+    return addon;
+  }
+
+  return addonOrProject.addons.find((addon) => findAddonByName(addon, name));
+}
+
+function ensureTargetDirIsAddon(addonPath) {
+  let projectInfo;
+
+  try {
+    projectInfo = require(path.join(addonPath, 'package.json'));
+  } catch (err) {
+    if (err.code === 'MODULE_NOT_FOUND') {
+      throw new Error(`The directory ${addonPath} does not appear to be a valid addon directory.`);
+    } else {
+      throw err;
+    }
+  }
+
+  return isAddon(projectInfo.keywords);
+}
+
+/**
+  @private
+  @method isValidFile
+  @param {Object} fileInfo
+  @return {Promise}
+*/
+function isValidFile(fileInfo) {
+  if (isIgnored(fileInfo)) {
+    return false;
+  } else {
+    return isFilePath(fileInfo);
+  }
+}
+
+/**
+  @private
+  @method isFilePath
+  @param {Object} fileInfo
+  @return {Promise}
+*/
+function isFilePath(fileInfo) {
+  return fs.statSync(fileInfo.inputPath).isFile();
+}
+
+/**
+ @private
+ @method dir
+ @return {Array} list of files in the given directory or and empty array if no directory exists
+*/
+function dir(fullPath) {
+  if (Blueprint._existsSync(fullPath)) {
+    return Blueprint._readdirSync(fullPath).map((fileName) => path.join(fullPath, fileName));
+  } else {
+    return [];
+  }
+}
+
+/**
+  @private
+  @method getDetailedHelpPath
+  @param {String} thisPath
+  @return {String} help path
+*/
+function getDetailedHelpPath(thisPath) {
+  return path.join(thisPath, './HELP.md');
+}
+
+function finishProcessingForInstall(infos) {
+  infos.forEach(markIdenticalToBeSkipped);
+
+  let infosNeedingConfirmation = infos.reduce(gatherConfirmationMessages, []);
+
+  return sequence(infosNeedingConfirmation).then(() => infos);
+}
+
+function finishProcessingForUninstall(infos) {
+  let validInfos = infos.filter((info) => fs.existsSync(info.outputPath));
+  validInfos.forEach(markToBeRemoved);
+
+  return validInfos;
+}
+
+function replaceExtension(filePath, newExt) {
+  const { dir, name } = path.parse(filePath);
+
+  return path.format({
+    dir,
+    name,
+    ext: newExt,
+  });
+}
+
+function replaceTypeScriptExtension(filePath) {
+  const extensionMap = {
+    '.ts': '.js',
+    '.gts': '.gjs',
+  };
+  const ext = path.extname(filePath);
+  const newExt = extensionMap[ext];
+
+  return replaceExtension(filePath, newExt);
+}
+
+function isTypeScriptFile(filePath) {
+  return path.extname(filePath) === '.ts' || path.extname(filePath) === '.gts';
+}
+
+/**
+ * Takes a substring of a string based on byte offsets.
+ * @private
+ * @method substringBytes
+ * @param {string} value : The input string.
+ * @param {number} start : The byte index of the substring start.
+ * @param {number} end : The byte index of the substring end.
+ * @return {string} : The substring.
+ */
+function substringBytes(value, start, end) {
+  let buf = Buffer.from(value);
+  return buf.subarray(start, end).toString();
+}
+
+module.exports = Blueprint;