piral-cli 0.15.0-alpha.4284 → 0.15.0-alpha.4332

package/src/apps/upgrade-pilet.ts

@@ -24,7 +24,6 @@ import {
   getPiralPath,
   isMonorepoPackageRef,
   getPiletScaffoldData,
-  SourceLanguage,
 } from '../common';
 
 export interface UpgradePiletOptions {
@@ -88,6 +87,7 @@ export async function upgradePilet(baseDir = process.cwd(), options: UpgradePile
     logLevel = upgradePiletDefaults.logLevel,
     install = upgradePiletDefaults.install,
     variables = upgradePiletDefaults.variables,
+    npmClient: defaultNpmClient = upgradePiletDefaults.npmClient,
   } = options;
   const fullBase = resolve(process.cwd(), baseDir);
   const root = resolve(fullBase, target);
@@ -98,13 +98,13 @@ export async function upgradePilet(baseDir = process.cwd(), options: UpgradePile
     fail('invalidPiletTarget_0040');
   }
 
-  const npmClient = await determineNpmClient(root, options.npmClient);
+  const npmClient = await determineNpmClient(root, defaultNpmClient);
   const pckg = await readJson(root, 'package.json');
   const { devDependencies = {}, dependencies = {}, piral, source } = pckg;
 
   if (piral && typeof piral === 'object') {
     const sourceName = piral.name;
-    const language = /\.jsx?$/.test(source) ? SourceLanguage.js : SourceLanguage.ts;
+    const language = /\.jsx?$/.test(source) ? 'js' : 'ts';
 
     if (!sourceName || typeof sourceName !== 'string') {
       fail('invalidPiletPackage_0042');

package/src/apps/upgrade-piral.ts

@@ -80,6 +80,7 @@ export async function upgradePiral(baseDir = process.cwd(), options: UpgradePira
     target = upgradePiralDefaults.target,
     logLevel = upgradePiralDefaults.logLevel,
     install = upgradePiralDefaults.install,
+    npmClient: defaultNpmClient = upgradePiralDefaults.npmClient,
   } = options;
   const fullBase = resolve(process.cwd(), baseDir);
   const root = resolve(fullBase, target);
@@ -91,7 +92,7 @@ export async function upgradePiral(baseDir = process.cwd(), options: UpgradePira
     fail('packageJsonNotFound_0020');
   }
 
-  const npmClient = await determineNpmClient(root, options.npmClient);
+  const npmClient = await determineNpmClient(root, defaultNpmClient);
 
   progress(`Checking provided version ...`);
   const realVersion = await findSpecificVersion('piral-cli', version);

package/src/commands.ts

@@ -6,9 +6,7 @@ import {
   forceOverwriteKeys,
   keyOfForceOverwrite,
   valueOfForceOverwrite,
-  keyOfSourceLanguage,
   sourceLanguageKeys,
-  valueOfSourceLanguage,
   frameworkKeys,
   clientTypeKeys,
   schemaKeys,
@@ -27,6 +25,7 @@ import {
   PiletSchemaVersion,
   PiletBuildType,
   PiletPublishScheme,
+  SourceLanguage,
 } from './types';
 
 function specializeCommand(commands: Array<ToolCommand<any>>, command: ToolCommand<any>, suffix: string) {
@@ -205,9 +204,9 @@ const allCommands: Array<ToolCommand<any>> = [
         .choices('provider', availableReleaseProviders)
         .describe('provider', 'Sets the provider for publishing the release assets.')
         .default('provider', apps.publishPiralDefaults.provider)
-        .option('fields', undefined)
-        .describe('fields', 'Sets additional fields to be included in the feed service request.')
-        .default('fields', apps.publishPiralDefaults.fields)
+        .option('opts', undefined)
+        .describe('opts', 'Sets the options to forward to the chosen provider.')
+        .default('opts', apps.publishPiralDefaults.opts)
         .boolean('interactive')
         .describe('interactive', 'Defines if authorization tokens can be retrieved interactively.')
         .default('interactive', apps.publishPiralDefaults.interactive)
@@ -221,7 +220,7 @@ const allCommands: Array<ToolCommand<any>> = [
         logLevel: args['log-level'] as LogLevels,
         type: args.type as PiralBuildType,
         provider: args.provider as string,
-        fields: args.fields as Record<string, string>,
+        opts: args.opts as Record<string, string>,
         interactive: args.interactive as boolean,
       });
     },
@@ -299,7 +298,7 @@ const allCommands: Array<ToolCommand<any>> = [
         .default('force-overwrite', keyOfForceOverwrite(apps.newPiralDefaults.forceOverwrite))
         .choices('language', sourceLanguageKeys)
         .describe('language', 'Determines the programming language for the new Piral instance.')
-        .default('language', keyOfSourceLanguage(apps.newPiralDefaults.language))
+        .default('language', apps.newPiralDefaults.language)
         .string('template')
         .describe('template', 'Sets the boilerplate template package to be used when scaffolding.')
         .default('template', apps.newPiralDefaults.template)
@@ -324,7 +323,7 @@ const allCommands: Array<ToolCommand<any>> = [
         version: args.tag as string,
         registry: args.registry as string,
         forceOverwrite: valueOfForceOverwrite(args['force-overwrite'] as string),
-        language: valueOfSourceLanguage(args.language as string),
+        language: args.language as SourceLanguage,
         install: args.install as boolean,
         template: args.template as string,
         logLevel: args['log-level'] as LogLevels,
@@ -684,7 +683,7 @@ const allCommands: Array<ToolCommand<any>> = [
         .default('log-level', apps.newPiletDefaults.logLevel)
         .choices('language', sourceLanguageKeys)
         .describe('language', 'Determines the programming language for the new pilet.')
-        .default('language', keyOfSourceLanguage(apps.newPiletDefaults.language))
+        .default('language', apps.newPiletDefaults.language)
         .string('template')
         .describe('template', 'Sets the boilerplate template package to be used when scaffolding.')
         .default('template', apps.newPiletDefaults.template)
@@ -707,7 +706,7 @@ const allCommands: Array<ToolCommand<any>> = [
         source: args.source as string,
         registry: args.registry as string,
         forceOverwrite: valueOfForceOverwrite(args['force-overwrite'] as string),
-        language: valueOfSourceLanguage(args.language as string),
+        language: args.language as SourceLanguage,
         logLevel: args['log-level'] as LogLevels,
         install: args.install as boolean,
         template: args.template as string,

package/src/common/clients/index.ts

@@ -1,5 +1,6 @@
 import * as lerna from './lerna';
 import * as npm from './npm';
+import * as pnp from './pnp';
 import * as pnpm from './pnpm';
 import * as rush from './rush';
 import * as yarn from './yarn';
@@ -7,6 +8,7 @@ import * as yarn from './yarn';
 export const clients = {
   lerna,
   npm,
+  pnp,
   pnpm,
   rush,
   yarn,
@@ -14,7 +16,7 @@ export const clients = {
 
 type ClientName = keyof typeof clients;
 
-const directClients = ['npm', 'yarn', 'pnpm'];
+const directClients = ['npm', 'pnp', 'yarn', 'pnpm'];
 
 export function isWrapperClient(client: ClientName) {
   return !directClients.includes(client);

package/src/common/clients/npm.ts

@@ -47,6 +47,10 @@ export async function initProject(projectName: string, target: string) {}
 
 // Functions to exclusively use from npm client:
 
+export async function loginUser() {
+  await runNpmProcess(['login'], '.');
+}
+
 export async function unpackPackage(packageRef: string, target = '.', ...flags: Array<string>) {
   const ms = new MemoryStream();
   await runNpmProcess(['pack', packageRef, ...flags], target, ms);

package/src/common/clients/pnp.ts

@@ -0,0 +1,77 @@
+import { resolve } from 'path';
+import { log } from '../log';
+import { findFile } from '../io';
+import { runCommand } from '../scripts';
+import { MemoryStream } from '../MemoryStream';
+
+// Helpers:
+
+function runYarnProcess(args: Array<string>, target: string, output?: NodeJS.WritableStream) {
+  log('generalDebug_0003', 'Starting the Yarn PnP process ...');
+  const cwd = resolve(process.cwd(), target);
+  return runCommand('yarn', args, cwd, output);
+}
+
+function convert(flags: Array<string>) {
+  return flags.map((flag) => {
+    switch (flag) {
+      case '--save-exact':
+        return '--exact';
+      case '--save-dev':
+        return '--dev';
+      case '--no-save':
+        // unfortunately no (https://github.com/yarnpkg/yarn/issues/1743)
+        return '';
+      default:
+        return flag;
+    }
+  });
+}
+
+// Client interface functions:
+
+export async function installDependencies(target = '.', ...flags: Array<string>) {
+  const ms = new MemoryStream();
+  await runYarnProcess(['install', ...convert(flags)], target, ms);
+  log('generalDebug_0003', `Yarn PnP install dependencies result: ${ms.value}`);
+  return ms.value;
+}
+
+export async function installPackage(packageRef: string, target = '.', ...flags: Array<string>) {
+  const ms = new MemoryStream();
+  await runYarnProcess(['add', packageRef, ...convert(flags)], target, ms);
+  log('generalDebug_0003', `Yarn PnP install package result: ${ms.value}`);
+  return ms.value;
+}
+
+export async function detectClient(root: string) {
+  return !!(await findFile(root, '.pnp.cjs'));
+}
+
+export async function initProject(projectName: string, target: string) {}
+
+export async function isProject(root: string, packageRef: string) {
+  const details = await listProjects(root);
+
+  if (typeof details === 'object') {
+    return typeof details?.[packageRef]?.location === 'string';
+  }
+
+  return false;
+}
+
+// Functions to exclusively use from yarn client:
+
+export async function listProjects(target: string) {
+  const ms = new MemoryStream();
+
+  try {
+    await runYarnProcess(['workspaces', 'info'], target, ms);
+  } catch (e) {
+    log('generalDebug_0003', `yarn workspaces error: ${e}`);
+    return {};
+  }
+
+  log('generalDebug_0003', `yarn workspaces result: ${ms.value}`);
+  return JSON.parse(ms.value);
+}

package/src/common/clients/yarn.ts

@@ -7,7 +7,7 @@ import { MemoryStream } from '../MemoryStream';
 // Helpers:
 
 function runYarnProcess(args: Array<string>, target: string, output?: NodeJS.WritableStream) {
-  log('generalDebug_0003', 'Starting the Yarn@1 process ...');
+  log('generalDebug_0003', 'Starting the Yarn Classic process ...');
   const cwd = resolve(process.cwd(), target);
   return runCommand('yarn', args, cwd, output);
 }
@@ -33,14 +33,14 @@ function convert(flags: Array<string>) {
 export async function installDependencies(target = '.', ...flags: Array<string>) {
   const ms = new MemoryStream();
   await runYarnProcess(['install', ...convert(flags)], target, ms);
-  log('generalDebug_0003', `Yarn@1 install dependencies result: ${ms.value}`);
+  log('generalDebug_0003', `Yarn Classic install dependencies result: ${ms.value}`);
   return ms.value;
 }
 
 export async function installPackage(packageRef: string, target = '.', ...flags: Array<string>) {
   const ms = new MemoryStream();
   await runYarnProcess(['add', packageRef, ...convert(flags)], target, ms);
-  log('generalDebug_0003', `Yarn@1 install package result: ${ms.value}`);
+  log('generalDebug_0003', `Yarn Classic install package result: ${ms.value}`);
   return ms.value;
 }
 

package/src/common/config.ts

@@ -1,7 +1,6 @@
-import { SourceLanguage } from './enums';
 import { defaultRegistry } from './constants';
 import { rc } from '../external';
-import { NpmClientType, PiletSchemaVersion } from '../types';
+import { SourceLanguage, NpmClientType, PiletSchemaVersion } from '../types';
 
 export interface PiralCliConfig {
   /**
@@ -79,7 +78,7 @@ export const config: PiralCliConfig = rc(
     schemaVersion: 'v2' as const,
     openBrowser: false,
     port: 1234,
-    language: SourceLanguage.ts,
+    language: 'ts' as const,
     host: 'localhost',
     registry: defaultRegistry,
   },

package/src/common/emulator.ts

@@ -1,6 +1,6 @@
 import { join, resolve, relative } from 'path';
 import { findDependencyVersion, copyScaffoldingFiles, isValidDependency } from './package';
-import { createFileFromTemplateIfNotExists } from './template';
+import { createPiralStubIndexIfNotExists } from './template';
 import { filesTar, filesOnceTar } from './constants';
 import { cliVersion } from './info';
 import { createNpmPackage, makeExternals } from './npm';
@@ -116,7 +116,7 @@ export async function createEmulatorSources(
   await copyScaffoldingFiles(sourceDir, rootDir, piralPkg.files ?? []);
 
   // actually including this one hints that the app shell should have been included - which is forbidden
-  await createFileFromTemplateIfNotExists('piral', targetDir, 'index.js', ForceOverwrite.yes, {
+  await createPiralStubIndexIfNotExists(targetDir, 'index.js', ForceOverwrite.yes, {
     name: piralPkg.name,
     outFile: targetFile,
   });

package/src/common/enums.ts

@@ -3,8 +3,3 @@ export enum ForceOverwrite {
   prompt,
   yes,
 }
-
-export enum SourceLanguage {
-  ts,
-  js,
-}

package/src/common/interactive.ts

@@ -56,7 +56,11 @@ export function getTokenInteractively(url: string, httpsAgent: Agent): TokenResu
       )
       .then((res) => {
         const { loginUrl, callbackUrl, expires } = res.data;
-        console.log(`Use the URL below to complete the login. The link expires at ${new Date(expires)}.`);
+        const now = new Date();
+        const then = new Date(expires);
+        const diff = ~~((then.valueOf() - now.valueOf()) / (60 * 1000));
+
+        console.log(`Use the URL below to complete the login. The link expires in ${diff} minutes (${then}).`);
         console.log('===');
         console.log(loginUrl);
         console.log('===');

package/src/common/language.ts

@@ -1,45 +1,93 @@
 import { log } from './log';
-import { SourceLanguage } from './enums';
+import { Framework, SourceLanguage } from '../types';
 
-export const reactDeps = {
+const react17Deps = {
   react: '^17',
   'react-dom': '^17',
+};
+
+const react18Deps = {
+  react: '^18',
+  'react-dom': '^18',
+};
+
+const reactRouter5Deps = {
   'react-router': '^5',
   'react-router-dom': '^5',
 };
 
-export const reactTypings = {
+const reactRouter6Deps = {
+  'react-router': '^6',
+  'react-router-dom': '^6',
+};
+
+const react17Typings = {
   '@types/react': '^17',
   '@types/react-dom': '^17',
+};
+
+const react18Typings = {
+  '@types/react': '^18',
+  '@types/react-dom': '^18',
+};
+
+const reactRouter5Typings = {
   '@types/react-router': '^5',
   '@types/react-router-dom': '^5',
 };
 
-export function getDependencies(language: SourceLanguage, packages: Record<string, string> = reactDeps) {
+const defaultDeps = {};
+
+const defaultTypings = {
+  '@types/react': '*',
+  '@types/react-dom': '*',
+};
+
+export function getDependencyPackages(framework: Framework, reactVersion: number, reactRouterVersion: number) {
+  // take default packages only if piral-core
+  return framework !== 'piral-core'
+    ? {}
+    : {
+        ...(reactVersion < 18 ? react17Deps : react18Deps),
+        ...(reactRouterVersion < 6 ? reactRouter5Deps : reactRouter6Deps),
+      };
+}
+
+export function getDevDependencyPackages(framework: Framework, reactVersion: number, reactRouterVersion: number) {
+  // take default dev packages only if not piral-base
+  return framework === 'piral-base'
+    ? {}
+    : {
+        ...(reactVersion < 18 ? react17Typings : react18Typings),
+        ...(reactRouterVersion < 6 ? reactRouter5Typings : {}),
+      };
+}
+
+export function getDependencies(language: SourceLanguage, packages: Record<string, string> = defaultDeps) {
   switch (language) {
-    case SourceLanguage.js:
-    case SourceLanguage.ts:
+    case 'js':
+    case 'ts':
       return {
         ...packages,
       };
     default:
-      log('generalDebug_0003', 'Did not find a valid language. Just skipping devDependencies.');
+      log('generalDebug_0003', 'Did not find a valid language. Skipping "dependencies".');
       return {};
   }
 }
 
-export function getDevDependencies(language: SourceLanguage, typings: Record<string, string> = reactTypings) {
+export function getDevDependencies(language: SourceLanguage, typings: Record<string, string> = defaultTypings) {
   switch (language) {
-    case SourceLanguage.ts:
+    case 'ts':
       return {
         ...typings,
         '@types/node': 'latest',
         typescript: 'latest',
       };
-    case SourceLanguage.js:
+    case 'js':
       return {};
     default:
-      log('generalDebug_0003', 'Did not find a valid language. Just skipping devDependencies.');
+      log('generalDebug_0003', 'Did not find a valid language. Skipping "devDependencies".');
       return {};
   }
 }

package/src/common/npm.ts

@@ -43,6 +43,10 @@ async function detectMonorepoRoot(root: string): Promise<[] | [string, NpmClient
     const packageJson = await readJson(root, 'package.json');
 
     if (Array.isArray(packageJson?.workspaces)) {
+      if (await checkExists(resolve(root, '.pnp.cjs'))) {
+        return [root, 'pnp'];
+      }
+
       if (await checkExists(resolve(root, 'yarn.lock'))) {
         return [root, 'yarn'];
       }
@@ -74,8 +78,6 @@ export async function determineNpmClient(root: string, selected?: NpmClientType)
       `Results of the lock file check: ${searchedClients.map((m) => `${m.client}=${m.result}`).join(', ')}`,
     );
 
-    const defaultClient = config.npmClient;
-
     if (foundClients.length > 1) {
       const wrapperClient = foundClients.find((m) => isWrapperClient(m.client));
 
@@ -97,12 +99,14 @@ export async function determineNpmClient(root: string, selected?: NpmClientType)
       return client;
     }
 
+    const defaultClient = config.npmClient;
+
     if (clientTypeKeys.includes(defaultClient)) {
       log('generalDebug_0003', `Using the default client: "${defaultClient}".`);
       return defaultClient;
     }
 
-    log('generalDebug_0003', 'Using the default "npm" client.');
+    log('generalDebug_0003', 'Using the fallback "npm" client.');
     return 'npm';
   }
 
@@ -148,9 +152,20 @@ export function initNpmProject(client: NpmClientType, projectName: string, targe
   return initProject(projectName, target);
 }
 
-export function publishNpmPackage(target = '.', file = '*.tgz', flags: Array<string> = []): Promise<string> {
-  const { publishPackage } = clients.npm;
-  return publishPackage(target, file, ...flags);
+export function publishNpmPackage(
+  target = '.',
+  file = '*.tgz',
+  flags: Array<string> = [],
+  interactive = false,
+): Promise<string> {
+  const { publishPackage, loginUser } = clients.npm;
+  return publishPackage(target, file, ...flags).catch(err => {
+    if (!interactive) {
+      throw err;
+    }
+
+    return loginUser().then(() => publishNpmPackage(target, file, flags, false));
+  });
 }
 
 export function createNpmPackage(target = '.'): Promise<string> {

package/src/common/package.test.ts

@@ -1,6 +1,5 @@
 import { findPackageVersion, getPiralPackage, getPiletsInfo, retrievePiletData } from './package';
 import { cliVersion } from './info';
-import { SourceLanguage } from './enums';
 
 describe('CLI package module', () => {
   it('findPackageVersion finds the current package version', async () => {
@@ -48,9 +47,18 @@ describe('CLI package module', () => {
   });
 
   it('getPiralPackage returns piral package', () => {
-    let result = getPiralPackage('app', SourceLanguage.ts, '1.0.0', 'piral-base', 'webpack');
+    let result = getPiralPackage(
+      'app',
+      { language: 'ts', packageName: 'piral-base', reactRouterVersion: 5, reactVersion: 17 },
+      '1.0.0',
+      'webpack',
+    );
     expect(result.devDependencies['piral-cli-webpack']).toEqual('1.0.0');
-    result = getPiralPackage('app', SourceLanguage.ts, '1.0.0', 'piral-base');
+    result = getPiralPackage(
+      'app',
+      { language: 'ts', packageName: 'piral-base', reactRouterVersion: 5, reactVersion: 17 },
+      '1.0.0',
+    );
     expect(result.devDependencies).not.toContain('piral-cli-webpack');
   });
 

package/src/common/package.ts

@@ -2,18 +2,17 @@ import { resolve, join, extname, basename, dirname, relative } from 'path';
 import { log, fail } from './log';
 import { cliVersion } from './info';
 import { unpackTarball } from './archive';
-import { getDependencies, getDevDependencies } from './language';
-import { SourceLanguage, ForceOverwrite } from './enums';
+import { getDependencies, getDependencyPackages, getDevDependencies, getDevDependencyPackages } from './language';
+import { ForceOverwrite } from './enums';
 import { checkAppShellCompatibility } from './compatibility';
 import { deepMerge } from './merge';
-import { applyTemplate } from './template';
 import { readImportmap } from './importmap';
 import { filesTar, filesOnceTar, declarationEntryExtensions, bundlerNames } from './constants';
 import { getHash, checkIsDirectory, matchFiles } from './io';
 import { readJson, copy, updateExistingJson, findFile, checkExists } from './io';
 import { isGitPackage, isLocalPackage, makeGitUrl, makeFilePath } from './npm';
 import { makePiletExternals, makeExternals, findPackageRoot } from './npm';
-import { Framework, FileInfo, PiletsInfo, TemplateFileLocation, PackageData } from '../types';
+import { SourceLanguage, Framework, FileInfo, PiletsInfo, TemplateFileLocation, PackageData } from '../types';
 
 function appendBundler(devDependencies: Record<string, string>, bundler: string, version: string) {
   if (bundler && bundler !== 'none') {
@@ -49,7 +48,6 @@ function getDependencyVersion(
 interface FileDescriptor {
   sourcePath: string;
   targetPath: string;
-  template: boolean;
 }
 
 const globPatternStartIndicators = ['*', '?', '[', '!(', '?(', '+(', '@('];
@@ -59,12 +57,7 @@ async function getMatchingFiles(
   target: string,
   file: string | TemplateFileLocation,
 ): Promise<Array<FileDescriptor>> {
-  const {
-    from,
-    to,
-    deep = true,
-    template = false,
-  } = typeof file === 'string' ? { from: file, to: file, deep: true } : file;
+  const { from, to, deep = true } = 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);
@@ -76,7 +69,6 @@ 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}".`);
@@ -98,7 +90,6 @@ async function getMatchingFiles(
     return files.map((file) => ({
       sourcePath: file,
       targetPath: resolve(tarRoot, relative(relRoot, file)),
-      template,
     }));
   }
 
@@ -108,7 +99,6 @@ async function getMatchingFiles(
     {
       sourcePath,
       targetPath,
-      template,
     },
   ];
 }
@@ -155,23 +145,24 @@ export function readPiralPackage(root: string, name: string): Promise<PackageDat
   return readJson(path, 'package.json');
 }
 
-export function getPiralPackage(
-  app: string,
-  language: SourceLanguage,
-  version: string,
-  framework: Framework,
-  bundler?: string,
-) {
-  // take default packages only if piral-core
-  const packages = framework !== 'piral-core' ? {} : undefined;
-  // take default dev packages only if not piral-base
-  const typings = framework === 'piral-base' ? {} : undefined;
+export interface PiralPackageData {
+  packageName: Framework;
+  language: SourceLanguage;
+  reactVersion: number;
+  reactRouterVersion: number;
+}
+
+export function getPiralPackage(app: string, data: PiralPackageData, version: string, bundler?: string) {
+  const framework = data.packageName;
   const devDependencies = {
-    ...getDevDependencies(language, typings),
+    ...getDevDependencies(
+      data.language,
+      getDevDependencyPackages(framework, data.reactVersion, data.reactRouterVersion),
+    ),
     'piral-cli': `${version}`,
   };
   const dependencies = {
-    ...getDependencies(language, packages),
+    ...getDependencies(data.language, getDependencyPackages(framework, data.reactVersion, data.reactRouterVersion)),
   };
 
   appendBundler(devDependencies, bundler, version);
@@ -219,7 +210,6 @@ async function getAvailableFiles(
   return files.map((file) => ({
     sourcePath: file,
     targetPath: resolve(root, relative(base, file)),
-    template: fileMap.find((m) => resolve(source, m.from) === file)?.template || false,
   }));
 }
 
@@ -249,17 +239,13 @@ async function copyFiles(
   variables?: Record<string, string>,
 ) {
   for (const subfile of subfiles) {
-    const { sourcePath, targetPath, template } = subfile;
+    const { sourcePath, targetPath } = subfile;
     const exists = await checkExists(sourcePath);
 
     if (exists) {
       const overwrite = originalFiles.some((m) => m.path === targetPath && !m.changed);
       const force = overwrite ? ForceOverwrite.yes : forceOverwrite;
-      const written = await copy(sourcePath, targetPath, force);
-
-      if (written && template && variables) {
-        await applyTemplate(targetPath, variables);
-      }
+      await copy(sourcePath, targetPath, force);
     } else {
       fail('cannotFindFile_0046', sourcePath);
     }