piral-cli 0.14.0-beta.3183 → 0.14.0-beta.3215

package/src/apps/build-piral.ts

@@ -107,6 +107,20 @@ export interface BuildPiralOptions {
    * Additional arguments for a specific bundler.
    */
   _?: Record<string, any>;
+
+  /**
+   * Hooks to be triggered at various stages.
+   */
+  hooks?: {
+    onBegin?(e: any): Promise<void>;
+    beforeBuild?(e: any): Promise<void>;
+    afterBuild?(e: any): Promise<void>;
+    beforeEmulator?(e: any): Promise<void>;
+    afterEmulator?(e: any): Promise<void>;
+    beforePackage?(e: any): Promise<void>;
+    afterPackage?(e: any): Promise<void>;
+    onEnd?(e: any): Promise<void>;
+  };
 }
 
 export const buildPiralDefaults: BuildPiralOptions = {
@@ -149,11 +163,14 @@ export async function buildPiral(baseDir = process.cwd(), options: BuildPiralOpt
     type = buildPiralDefaults.type,
     optimizeModules = buildPiralDefaults.optimizeModules,
     _ = {},
+    hooks = {},
     bundlerName,
   } = options;
   const fullBase = resolve(process.cwd(), baseDir);
   const useSubdir = type === 'all' || subdir;
   setLogLevel(logLevel);
+
+  await hooks.onBegin?.({ options, fullBase });
   progress('Reading configuration ...');
   const entryFiles = await retrievePiralRoot(fullBase, entry);
   const { name, root, ignored, externals, scripts } = await retrievePiletsInfo(entryFiles);
@@ -174,8 +191,10 @@ export async function buildPiral(baseDir = process.cwd(), options: BuildPiralOpt
     // since we create this anyway let's just pretend we want to have it clean!
     await removeDirectory(targetDir);
 
+    await hooks.beforeBuild?.({ root, publicUrl, externals, entryFiles, targetDir, name });
+
     logInfo(`Bundle ${emulatorName} ...`);
-    const { dir: outDir, name: outFile } = await callPiralBuild(
+    const { dir: outDir, name: outFile, hash } = await callPiralBuild(
       {
         root,
         piral: name,
@@ -196,13 +215,21 @@ export async function buildPiral(baseDir = process.cwd(), options: BuildPiralOpt
       bundlerName,
     );
 
+    await hooks.afterBuild?.({ root, publicUrl, externals, entryFiles, targetDir, name, outDir, hash, outFile });
+
     await runLifecycle(root, scripts, 'piral:postbuild');
     await runLifecycle(root, scripts, `piral:postbuild-${emulatorName}`);
+    
+    await hooks.beforeEmulator?.({ root, externals, targetDir, outDir });
 
     const rootDir = await createEmulatorSources(root, outDir, outFile, logLevel);
+    
+    await hooks.afterEmulator?.({ root, externals, targetDir, outDir, rootDir });
 
     if (type !== emulatorSourcesName) {
+      await hooks.beforePackage?.({ root, externals, targetDir, outDir, rootDir });
       await packageEmulator(rootDir);
+      await hooks.afterPackage?.({ root, externals, targetDir, outDir, rootDir });
       logDone(`Emulator package available in "${rootDir}".`);
     } else {
       logDone(`Emulator sources available in "${rootDir}".`);
@@ -220,7 +247,10 @@ export async function buildPiral(baseDir = process.cwd(), options: BuildPiralOpt
     await removeDirectory(targetDir);
 
     logInfo(`Bundle ${releaseName} ...`);
-    const { dir: outDir } = await callPiralBuild(
+    
+    await hooks.beforeBuild?.({ root, publicUrl, externals, entryFiles, targetDir, name });
+
+    const { dir: outDir, name: outFile, hash } = await callPiralBuild(
       {
         root,
         piral: name,
@@ -240,6 +270,8 @@ export async function buildPiral(baseDir = process.cwd(), options: BuildPiralOpt
       },
       bundlerName,
     );
+    
+    await hooks.afterBuild?.({ root, publicUrl, externals, entryFiles, targetDir, name, outDir, outFile, hash });
 
     await runLifecycle(root, scripts, 'piral:postbuild');
     await runLifecycle(root, scripts, `piral:postbuild-${releaseName}`);
@@ -247,4 +279,6 @@ export async function buildPiral(baseDir = process.cwd(), options: BuildPiralOpt
     logDone(`Files for publication available in "${outDir}".`);
     logReset();
   }
+
+  await hooks.onEnd?.({ root });
 }

package/src/apps/debug-pilet.ts

@@ -73,6 +73,18 @@ export interface DebugPiletOptions {
    * Additional arguments for a specific bundler.
    */
   _?: Record<string, any>;
+
+  /**
+   * Hooks to be triggered at various stages.
+   */
+  hooks?: {
+    onBegin?(e: any): Promise<void>;
+    beforeBuild?(e: any): Promise<void>;
+    afterBuild?(e: any): Promise<void>;
+    beforeOnline?(e: any): Promise<void>;
+    afterOnline?(e: any): Promise<void>;
+    onEnd?(e: any): Promise<void>;
+  };
 }
 
 export const debugPiletDefaults: DebugPiletOptions = {
@@ -142,19 +154,23 @@ export async function debugPilet(baseDir = process.cwd(), options: DebugPiletOpt
     optimizeModules = debugPiletDefaults.optimizeModules,
     schemaVersion = debugPiletDefaults.schemaVersion,
     _ = {},
+    hooks = {},
     bundlerName,
     app,
     feed,
   } = options;
+  const fullBase = resolve(process.cwd(), baseDir);
   setLogLevel(logLevel);
+
+  await hooks.onBegin?.({ options, fullBase });
   progress('Reading configuration ...');
   const krasConfig = readKrasConfig({ port }, krasrc);
   const api = config.piletApi;
   const entryList = Array.isArray(entry) ? entry : [entry];
   const multi = entryList.length > 1 || entryList[0].indexOf('*') !== -1;
-  log('generalDebug_0003', `Looking for (${multi ? 'multi' : 'single'}) "${entryList.join('", "')}" in "${baseDir}".`);
+  log('generalDebug_0003', `Looking for (${multi ? 'multi' : 'single'}) "${entryList.join('", "')}" in "${fullBase}".`);
 
-  const allEntries = await matchAnyPilet(baseDir, entryList);
+  const allEntries = await matchAnyPilet(fullBase, entryList);
   log('generalDebug_0003', `Found the following entries: ${allEntries.join(', ')}`);
 
   if (krasConfig.sources === undefined) {
@@ -168,10 +184,8 @@ export async function debugPilet(baseDir = process.cwd(), options: DebugPiletOpt
   const pilets = await Promise.all(
     allEntries.map(async (entryModule) => {
       const targetDir = dirname(entryModule);
-      const { peerDependencies, peerModules, root, appPackage, appFile, ignored, emulator, importmap } = await retrievePiletData(
-        targetDir,
-        app,
-      );
+      const { peerDependencies, peerModules, root, appPackage, appFile, ignored, emulator, importmap } =
+        await retrievePiletData(targetDir, app);
       const externals = [...Object.keys(peerDependencies), ...peerModules];
       const mocks = join(targetDir, 'mocks');
       const exists = await checkExistingDirectory(mocks);
@@ -184,6 +198,8 @@ export async function debugPilet(baseDir = process.cwd(), options: DebugPiletOpt
         krasConfig.sources.push(mocks);
       }
 
+      await hooks.beforeBuild?.({ root, importmap, entryModule, schemaVersion });
+
       const bundler = await callPiletDebug(
         {
           root,
@@ -202,6 +218,8 @@ export async function debugPilet(baseDir = process.cwd(), options: DebugPiletOpt
         bundlerName,
       );
 
+      await hooks.afterBuild?.({ root, importmap, entryModule, schemaVersion, bundler });
+
       return {
         emulator,
         appFile,
@@ -260,7 +278,10 @@ export async function debugPilet(baseDir = process.cwd(), options: DebugPiletOpt
     ),
   );
 
+  await hooks.beforeOnline?.({ krasServer, krasConfig, open, port, api, feed, pilets });
   await krasServer.start();
   openBrowser(open, port);
+  await hooks.afterOnline?.({ krasServer, krasConfig, open, port, api, feed, pilets });
   await new Promise((resolve) => krasServer.on('close', resolve));
+  await hooks.onEnd?.({});
 }

package/src/apps/debug-piral.ts

@@ -60,6 +60,18 @@ export interface DebugPiralOptions {
    * Additional arguments for a specific bundler.
    */
   _?: Record<string, any>;
+
+  /**
+   * Hooks to be triggered at various stages.
+   */
+  hooks?: {
+    onBegin?(e: any): Promise<void>;
+    beforeBuild?(e: any): Promise<void>;
+    afterBuild?(e: any): Promise<void>;
+    beforeOnline?(e: any): Promise<void>;
+    afterOnline?(e: any): Promise<void>;
+    onEnd?(e: any): Promise<void>;
+  };
 }
 
 export const debugPiralDefaults: DebugPiralOptions = {
@@ -84,10 +96,13 @@ export async function debugPiral(baseDir = process.cwd(), options: DebugPiralOpt
     logLevel = debugPiralDefaults.logLevel,
     optimizeModules = debugPiralDefaults.optimizeModules,
     _ = {},
+    hooks = {},
     bundlerName,
   } = options;
   const fullBase = resolve(process.cwd(), baseDir);
   setLogLevel(logLevel);
+
+  await hooks.onBegin?.({ options, fullBase });
   progress('Reading configuration ...');
   const entryFiles = await retrievePiralRoot(fullBase, entry);
   const { externals, name, root, ignored } = await retrievePiletsInfo(entryFiles);
@@ -115,6 +130,8 @@ export async function debugPiral(baseDir = process.cwd(), options: DebugPiralOpt
     krasConfig.injectors = defaultConfig.injectors;
   }
 
+  await hooks.beforeBuild?.({ root, publicUrl, externals, entryFiles, name });
+
   const bundler = await callPiralDebug(
     {
       root,
@@ -130,6 +147,7 @@ export async function debugPiral(baseDir = process.cwd(), options: DebugPiralOpt
     },
     bundlerName,
   );
+  await hooks.afterBuild?.({ root, publicUrl, externals, entryFiles, name, bundler });
 
   const injectorConfig = {
     active: true,
@@ -146,7 +164,10 @@ export async function debugPiral(baseDir = process.cwd(), options: DebugPiralOpt
   krasServer.removeAllListeners('open');
   krasServer.on('open', notifyServerOnline([bundler], krasConfig.api));
 
+  await hooks.beforeOnline?.({ krasServer, krasConfig, open, port });
   await krasServer.start();
   openBrowser(open, port);
+  await hooks.afterOnline?.({ krasServer, krasConfig, open, port });
   await new Promise((resolve) => krasServer.on('close', resolve));
+  await hooks.onEnd?.({});
 }

package/src/apps/new-pilet.ts

@@ -192,17 +192,18 @@ always-auth=true`,
     }
 
     progress(`Taking care of templating ...`);
+    variables.sourceName = sourceName;
 
     await scaffoldPiletSourceFiles(template, registry, language, root, packageName, forceOverwrite, variables);
 
     if (isEmulator) {
       // in the emulator case we get the files (and files_once) from the contained tarballs
-      await copyPiralFiles(root, packageName, piralInfo, ForceOverwrite.yes);
+      await copyPiralFiles(root, packageName, piralInfo, ForceOverwrite.yes, variables);
     } else {
       // otherwise, we perform the same action as in the emulator creation
       // just with a different target; not a created directory, but the root
       const packageRoot = getPiralPath(root, packageName);
-      await copyScaffoldingFiles(packageRoot, root, files, piralInfo);
+      await copyScaffoldingFiles(packageRoot, root, files, piralInfo, variables);
     }
 
     await patchPiletPackage(root, packageName, packageVersion, piralInfo, isEmulator, {

package/src/apps/upgrade-pilet.ts

@@ -63,6 +63,11 @@ export interface UpgradePiletOptions {
    * works against Lerna, pnpm, and Yarn.
    */
   npmClient?: NpmClientType;
+
+  /**
+   * Places additional variables that should used when scaffolding.
+   */
+  variables?: Record<string, string>;
 }
 
 export const upgradePiletDefaults: UpgradePiletOptions = {
@@ -72,6 +77,7 @@ export const upgradePiletDefaults: UpgradePiletOptions = {
   logLevel: LogLevels.info,
   install: true,
   npmClient: undefined,
+  variables: {},
 };
 
 export async function upgradePilet(baseDir = process.cwd(), options: UpgradePiletOptions = {}) {
@@ -81,6 +87,7 @@ export async function upgradePilet(baseDir = process.cwd(), options: UpgradePile
     forceOverwrite = upgradePiletDefaults.forceOverwrite,
     logLevel = upgradePiletDefaults.logLevel,
     install = upgradePiletDefaults.install,
+    variables = upgradePiletDefaults.variables,
   } = options;
   const fullBase = resolve(process.cwd(), baseDir);
   const root = resolve(fullBase, target);
@@ -137,16 +144,17 @@ export async function upgradePilet(baseDir = process.cwd(), options: UpgradePile
     }
 
     progress(`Taking care of templating ...`);
+    variables.sourceName = sourceName;
 
     if (isEmulator) {
       // in the emulator case we get the files from the contained tarball
-      await copyPiralFiles(root, sourceName, piralInfo, forceOverwrite, originalFiles);
+      await copyPiralFiles(root, sourceName, piralInfo, forceOverwrite, variables, originalFiles);
     } else {
       // otherwise, we perform the same action as in the emulator creation
       // just with a different target; not a created directory, but the root
       const packageRoot = getPiralPath(root, sourceName);
       const notOnceFiles = files.filter((m) => typeof m === 'string' || !m.once);
-      await copyScaffoldingFiles(packageRoot, root, notOnceFiles, piralInfo);
+      await copyScaffoldingFiles(packageRoot, root, notOnceFiles, piralInfo, variables);
     }
 
     await patchPiletPackage(root, sourceName, packageVersion, piralInfo, isEmulator);

package/src/commands.ts

@@ -682,6 +682,9 @@ const allCommands: Array<ToolCommand<any>> = [
         .choices('npm-client', clientTypeKeys)
         .describe('npm-client', 'Sets the npm client to be used when upgrading.')
         .default('npm-client', apps.upgradePiletDefaults.npmClient)
+        .option('vars', undefined)
+        .describe('vars', 'Sets additional variables to be used when scaffolding.')
+        .default('vars', apps.upgradePiletDefaults.variables)
         .string('base')
         .default('base', process.cwd())
         .describe('base', 'Sets the base directory. By default the current directory is used.');
@@ -694,6 +697,7 @@ const allCommands: Array<ToolCommand<any>> = [
         forceOverwrite: valueOfForceOverwrite(args['force-overwrite'] as string),
         install: args.install as boolean,
         npmClient: args['npm-client'] as NpmClientType,
+        variables: args.vars as Record<string, string>,
       });
     },
   },

package/src/common/emulator.ts

@@ -46,11 +46,13 @@ export async function createEmulatorSources(
   const filesOnceDir = resolve(rootDir, filesOnceTar);
 
   const filesMap = files
+    .filter((file) => file && (typeof file === 'string' || typeof file === 'object'))
     .map((file) => (typeof file === 'string' ? { from: file, to: file } : file))
+    .filter((file) => typeof file.to === 'string' && typeof file.from === 'string')
     .map((file) => ({
       ...file,
       to: file.to.replace(/\\/g, '/'),
-      from: join('files', file.from).replace(/\\/g, '/'),
+      from: join('files', file.to).replace(/\\/g, '/'),
     }));
 
   // do not modify an existing JSON

package/src/common/log.ts

@@ -11,10 +11,15 @@ type MessageTypes = keyof Messages;
 
 const logger = (() => {
   try {
-    return require('@parcel/logger');
-  } catch {
-    return require('../external').logger;
-  }
+    const logger = require('@parcel/logger');
+
+    // check to see if this is really right
+    if (typeof logger.verbose === 'function') {
+      return logger;
+    }
+  } catch {}
+
+  return require('../external').logger;
 })();
 
 // unfortunately, Parcel's support for verbose logging on Windows is broken

package/src/common/package.ts

@@ -7,7 +7,8 @@ import { SourceLanguage, ForceOverwrite } from './enums';
 import { checkAppShellCompatibility } from './compatibility';
 import { deepMerge } from './merge';
 import { getHashFromUrl } from './http';
-import { isGitPackage, isLocalPackage, makeGitUrl, makeFilePath, makePiletExternals } from './npm';
+import { applyTemplate } from './template';
+import { isGitPackage, isLocalPackage, makeGitUrl, makeFilePath, makePiletExternals, makeExternals } from './npm';
 import { filesTar, filesOnceTar, declarationEntryExtensions } from './constants';
 import { getHash, checkIsDirectory, matchFiles } from './io';
 import { readJson, copy, updateExistingJson, findFile, checkExists } from './io';
@@ -31,6 +32,7 @@ function getDependencyVersion(
 interface FileDescriptor {
   sourcePath: string;
   targetPath: string;
+  template: boolean;
 }
 
 const globPatternStartIndicators = ['*', '?', '[', '!(', '?(', '+(', '@('];
@@ -40,7 +42,12 @@ async function getMatchingFiles(
   target: string,
   file: string | TemplateFileLocation,
 ): Promise<Array<FileDescriptor>> {
-  const { from, to, deep = true } = typeof file === 'string' ? { from: file, to: file, deep: true } : file;
+  const {
+    from,
+    to,
+    deep = true,
+    template = false,
+  } = typeof file === 'string' ? { from: file, to: file, deep: true } : file;
   const sourcePath = resolve(source, from);
   const targetPath = resolve(target, to);
   const isDirectory = await checkIsDirectory(sourcePath);
@@ -52,6 +59,7 @@ async function getMatchingFiles(
     return files.map((file) => ({
       sourcePath: file,
       targetPath: resolve(targetPath, relative(sourcePath, file)),
+      template,
     }));
   } else if (globPatternStartIndicators.some((m) => from.indexOf(m) !== -1)) {
     log('generalDebug_0003', `Matching using glob "${sourcePath}".`);
@@ -73,6 +81,7 @@ async function getMatchingFiles(
     return files.map((file) => ({
       sourcePath: file,
       targetPath: resolve(tarRoot, relative(relRoot, file)),
+      template,
     }));
   }
 
@@ -82,6 +91,7 @@ async function getMatchingFiles(
     {
       sourcePath,
       targetPath,
+      template,
     },
   ];
 }
@@ -174,26 +184,35 @@ export function getPiralPackage(
   };
 }
 
-async function getAvailableFiles(root: string, name: string, tarBall: string): Promise<Array<FileDescriptor>> {
+async function getAvailableFiles(
+  root: string,
+  name: string,
+  dirName: string,
+  fileMap: Array<TemplateFileLocation>,
+): Promise<Array<FileDescriptor>> {
   const source = getPiralPath(root, name);
-  log('generalDebug_0003', `Checking if "files.tar" exists in "${source}" ...`);
-  const exists = await checkExists(resolve(source, `${tarBall}.tar`));
+  const tgz = `${dirName}.tar`;
+  log('generalDebug_0003', `Checking if "${tgz}" exists in "${source}" ...`);
+  const exists = await checkExists(resolve(source, tgz));
 
   if (exists) {
-    await unpackTarball(source, `${tarBall}.tar`);
+    await unpackTarball(source, tgz);
   }
 
   log('generalDebug_0003', `Get matching files from "${source}".`);
-  const base = resolve(source, tarBall);
+  const base = resolve(source, dirName);
   const files = await matchFiles(base, '**/*');
+
   return files.map((file) => ({
     sourcePath: file,
     targetPath: resolve(root, relative(base, file)),
+    template: fileMap.find((m) => resolve(base, m.from) === file)?.template || false,
   }));
 }
 
-export async function getFileStats(root: string, name: string) {
-  const files = await getAvailableFiles(root, name, filesTar);
+export async function getFileStats(root: string, name: string, fileMap: Array<TemplateFileLocation> = []) {
+  const files = await getAvailableFiles(root, name, filesTar, fileMap);
+
   return await Promise.all(
     files.map(async (file) => {
       const { sourcePath, targetPath } = file;
@@ -214,15 +233,20 @@ async function copyFiles(
   subfiles: Array<FileDescriptor>,
   forceOverwrite: ForceOverwrite,
   originalFiles: Array<FileInfo>,
+  variables?: Record<string, string>,
 ) {
   for (const subfile of subfiles) {
-    const { sourcePath, targetPath } = subfile;
+    const { sourcePath, targetPath, template } = subfile;
     const exists = await checkExists(sourcePath);
 
     if (exists) {
       const overwrite = originalFiles.some((m) => m.path === targetPath && !m.changed);
       const force = overwrite ? ForceOverwrite.yes : forceOverwrite;
-      await copy(sourcePath, targetPath, force);
+      const written = await copy(sourcePath, targetPath, force);
+
+      if (written && template && variables) {
+        await applyTemplate(targetPath, variables);
+      }
     } else {
       fail('cannotFindFile_0046', sourcePath);
     }
@@ -234,6 +258,7 @@ export async function copyScaffoldingFiles(
   target: string,
   files: Array<string | TemplateFileLocation>,
   piralInfo?: any,
+  variables?: Record<string, string>,
 ) {
   log('generalDebug_0003', `Copying the scaffolding files ...`);
   const allFiles: Array<FileDescriptor> = [];
@@ -247,7 +272,7 @@ export async function copyScaffoldingFiles(
     await extendPackageOverridesFromTemplateFragment(target, piralInfo, allFiles);
   }
 
-  await copyFiles(allFiles, ForceOverwrite.yes, []);
+  await copyFiles(allFiles, ForceOverwrite.yes, [], variables);
 }
 
 async function extendPackageOverridesFromTemplateFragment(root: string, piralInfo: any, files: Array<FileDescriptor>) {
@@ -276,24 +301,31 @@ async function extendPackageOverridesFromTemplateFragment(root: string, piralInf
   }
 }
 
+function isTemplateFileLocation(item: string | TemplateFileLocation): item is TemplateFileLocation {
+  return typeof item === 'object';
+}
+
 export async function copyPiralFiles(
   root: string,
   name: string,
   piralInfo: any,
   forceOverwrite: ForceOverwrite,
+  variables: Record<string, string>,
   originalFiles?: Array<FileInfo>,
 ) {
   log('generalDebug_0003', `Copying the Piral files ...`);
-  const files = await getAvailableFiles(root, name, filesTar);
+  const { files: _files } = getPiletsInfo(piralInfo);
+  const fileMap = _files.filter(isTemplateFileLocation);
+  const files = await getAvailableFiles(root, name, filesTar, fileMap);
 
   if (originalFiles === undefined) {
-    const initialFiles = await getAvailableFiles(root, name, filesOnceTar);
+    const initialFiles = await getAvailableFiles(root, name, filesOnceTar, fileMap);
     files.push(...initialFiles);
     originalFiles = [];
   }
 
   await extendPackageOverridesFromTemplateFragment(root, piralInfo, files);
-  await copyFiles(files, forceOverwrite, originalFiles);
+  await copyFiles(files, forceOverwrite, originalFiles, variables);
 }
 
 export function getPiletsInfo(piralInfo: any): PiletsInfo {
@@ -410,9 +442,12 @@ export async function retrievePiletsInfo(entryFile: string) {
   }
 
   const packageInfo = require(packageJson);
+  const info = getPiletsInfo(packageInfo);
+  const externals = makeExternals(info.externals);
 
   return {
-    ...getPiletsInfo(packageInfo),
+    ...info,
+    externals,
     name: packageInfo.name,
     version: packageInfo.version,
     dependencies: {

package/src/common/template.ts

@@ -1,13 +1,36 @@
 import { renderFile } from 'ejs';
+import { writeFile } from 'fs';
 import { resolve } from 'path';
 import { log } from './log';
 import { ForceOverwrite } from './enums';
 import { createFileIfNotExists } from './io';
 
+export async function applyTemplate(file: string, data: Record<string, string>) {
+  const content = await new Promise<string>((resolve, reject) => {
+    log('generalDebug_0003', `Filling template in "${file}".`);
+    renderFile(file, data, (err, str) => {
+      if (err) {
+        reject(err);
+      } else {
+        resolve(str);
+      }
+    });
+  });
+  await new Promise<void>((resolve, reject) => {
+    writeFile(file, content, 'utf8', (err) => {
+      if (err) {
+        reject(err);
+      } else {
+        resolve();
+      }
+    });
+  });
+}
+
 export function fillTemplate(name: string, data: any = {}) {
   const path = resolve(__dirname, '..', '..', 'templates', `${name}.ejs`);
   return new Promise<string>((resolve, reject) => {
-    log('generalDebug_0003', `Rendering template "{name}" in "${path}".`);
+    log('generalDebug_0003', `Rendering template "${name}" in "${path}".`);
     renderFile(path, data, (err, str) => {
       if (err) {
         reject(err);

package/src/types/common.ts

@@ -48,6 +48,7 @@ export interface ReleaseProvider {
 export interface TemplateFileLocation {
   from: string;
   to: string;
+  template?: boolean;
   deep?: boolean;
   once?: boolean;
 }