piral-cli 0.15.0-alpha.4311 → 0.15.0-alpha.4345

package/src/apps/new-pilet.ts

@@ -1,8 +1,7 @@
 import { resolve, basename } from 'path';
-import { LogLevels, NpmClientType } from '../types';
+import { SourceLanguage, LogLevels, NpmClientType } from '../types';
 import {
   ForceOverwrite,
-  SourceLanguage,
   createDirectory,
   createFileIfNotExists,
   installNpmPackage,

package/src/apps/new-piral.test.ts

@@ -2,7 +2,6 @@ import { mkdtempSync, existsSync } from 'fs';
 import { tmpdir } from 'os';
 import { join, resolve } from 'path';
 import { newPiral } from './new-piral';
-import { SourceLanguage } from '../common';
 
 function createTempDir() {
   return mkdtempSync(join(tmpdir(), 'piral-tests-new-piral-'));
@@ -19,9 +18,10 @@ jest.mock('../common/clients/npm', () => {
   };
 });
 
+jest.setTimeout(60000);
+
 describe('New Piral Command', () => {
   it('scaffolding in an empty directory works', async () => {
-    jest.setTimeout(60000);
     const dir = createTempDir();
     await newPiral(dir, { install: false });
     expect(existsSync(resolve(dir, 'node_modules/piral/package.json'))).toBeTruthy();
@@ -34,10 +34,9 @@ describe('New Piral Command', () => {
   });
 
   it('scaffolding with language JS works', async () => {
-    jest.setTimeout(60000);
     const dir = createTempDir();
     await newPiral(dir, {
-      language: SourceLanguage.js,
+      language: 'js',
       install: false,
     });
     expect(existsSync(resolve(dir, 'node_modules/piral/package.json'))).toBeTruthy();
@@ -50,7 +49,6 @@ describe('New Piral Command', () => {
   });
 
   it('scaffolding for piral-core works', async () => {
-    jest.setTimeout(60000);
     const dir = createTempDir();
     await newPiral(dir, {
       framework: 'piral-core',
@@ -68,7 +66,6 @@ describe('New Piral Command', () => {
   });
 
   it('scaffolding for piral-base works', async () => {
-    jest.setTimeout(60000);
     const dir = createTempDir();
     await newPiral(dir, {
       framework: 'piral-base',

package/src/apps/new-piral.ts

@@ -1,9 +1,8 @@
 import { resolve, basename } from 'path';
 import { frameworkKeys } from '../helpers';
-import { LogLevels, Framework, NpmClientType } from '../types';
+import { SourceLanguage, LogLevels, Framework, NpmClientType } from '../types';
 import {
   ForceOverwrite,
-  SourceLanguage,
   installNpmPackage,
   updateExistingJson,
   getPiralPackage,
@@ -177,14 +176,11 @@ always-auth=true`,
 
     progress(`Taking care of templating ...`);
 
-    await updateExistingJson(root, 'package.json', getPiralPackage(app, language, version, framework, bundlerName));
+    const data = getPiralScaffoldData(language, root, app, framework, variables);
 
-    await scaffoldPiralSourceFiles(
-      template,
-      registry,
-      getPiralScaffoldData(language, root, app, framework, variables),
-      forceOverwrite,
-    );
+    await updateExistingJson(root, 'package.json', getPiralPackage(app, data, version, bundlerName));
+
+    await scaffoldPiralSourceFiles(template, registry, data, forceOverwrite);
 
     if (install) {
       progress(`Installing dependencies ...`);

package/src/apps/upgrade-pilet.ts

@@ -24,7 +24,6 @@ import {
   getPiralPath,
   isMonorepoPackageRef,
   getPiletScaffoldData,
-  SourceLanguage,
 } from '../common';
 
 export interface UpgradePiletOptions {
@@ -105,7 +104,7 @@ export async function upgradePilet(baseDir = process.cwd(), options: UpgradePile
 
   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/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) {
@@ -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/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/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.test.ts

@@ -66,7 +66,7 @@ jest.mock('fs', () => ({
   existsSync: (file: string) => {
     return true;
   },
-  readFile: (file: string, type: string, callback: (err: NodeJS.ErrnoException, data: string) => void) => {
+  readFile: (file: string, type: string, callback: (err: NodeJS.ErrnoException | undefined, data: string) => void) => {
     return callback(undefined, '');
   },
   realpathSync: () => ({}),
@@ -320,7 +320,7 @@ describe('npm Module', () => {
   });
 
   it('check if package from nothing is not local', () => {
-    const result = isLocalPackage('./', null);
+    const result = isLocalPackage('./', '');
     expect(result).toBeFalsy();
   });
 
@@ -364,7 +364,7 @@ describe('npm Module', () => {
     expect(result).toBeTruthy();
     result = isGitPackage('git+');
     expect(result).toBeTruthy();
-    result = isGitPackage(null);
+    result = isGitPackage('');
     expect(result).toBeFalsy();
   });
 
@@ -395,11 +395,11 @@ describe('npm Module', () => {
   it('combine package refernce', () => {
     let result = combinePackageRef('foo', '1.0.0', 'registry');
     expect(result).toBe('foo@1.0.0');
-    result = combinePackageRef('foo', null, 'registry');
+    result = combinePackageRef('foo', '', 'registry');
     expect(result).toBe('foo@latest');
-    result = combinePackageRef('foo', null, 'file');
+    result = combinePackageRef('foo', '', 'file');
     expect(result).toBe('foo');
-    result = combinePackageRef('foo', null, 'git');
+    result = combinePackageRef('foo', '', 'git');
     expect(result).toBe('foo');
   });
 
@@ -430,18 +430,18 @@ describe('npm Module', () => {
     expect(result).toEqual('1.0.0');
     result = getPackageVersion(false, 'foo', '1.0.0', 'registry', './');
     expect(result).toBeFalsy();
-    result = getPackageVersion(true, './foo.tgz', null, 'file', './');
+    result = getPackageVersion(true, './foo.tgz', '', 'file', './');
     expect(result).toEqual('file:foo.tgz');
-    result = getPackageVersion(true, 'git+https://.foo.git', null, 'git', null);
+    result = getPackageVersion(true, 'git+https://.foo.git', '', 'git', '');
     expect(result).toEqual('git+https://.foo.git');
   });
 
   it('gets path to git package', () => {
-    const result = getCurrentPackageDetails('./', './foo.tgz', null, 'file://foo.tgz', './');
+    const result = getCurrentPackageDetails('./', './foo.tgz', '', 'file://foo.tgz', './');
     result.then(([path, version]) => {
       expect(path).not.toBeUndefined();
     });
-    const result2 = getCurrentPackageDetails('./', './foo.tgz', null, 'git+https://.foo.git', './');
+    const result2 = getCurrentPackageDetails('./', './foo.tgz', '', 'git+https://.foo.git', './');
     result2.then(([path, version]) => {
       expect(path).not.toBeUndefined();
     });
@@ -454,32 +454,12 @@ describe('npm Module', () => {
 
   it('makeExternals without externals returns coreExternals', () => {
     const externals = makeExternals(process.cwd(), { piral: '*' });
-    expect(externals).toEqual([
-      'react',
-      'react-dom',
-      'react-router',
-      'react-router-dom',
-      'history',
-      'tslib',
-      'path-to-regexp',
-      '@libre/atom',
-      '@dbeining/react-atom',
-    ]);
+    expect(externals).toEqual(['react', 'react-dom', 'react-router', 'react-router-dom', 'history', 'tslib']);
   });
 
   it('makeExternals with no externals returns coreExternals', () => {
     const externals = makeExternals(process.cwd(), { piral: '*' }, []);
-    expect(externals).toEqual([
-      'react',
-      'react-dom',
-      'react-router',
-      'react-router-dom',
-      'history',
-      'tslib',
-      'path-to-regexp',
-      '@libre/atom',
-      '@dbeining/react-atom',
-    ]);
+    expect(externals).toEqual(['react', 'react-dom', 'react-router', 'react-router-dom', 'history', 'tslib']);
   });
 
   it('makeExternals with exclude coreExternals returns empty set', () => {
@@ -498,41 +478,17 @@ describe('npm Module', () => {
       'react-router-dom',
       'history',
       'tslib',
-      'path-to-regexp',
-      '@libre/atom',
-      '@dbeining/react-atom',
     ]);
   });
 
   it('makeExternals with external duplicate only reflects coreExternals', () => {
     const externals = makeExternals(process.cwd(), { piral: '*' }, ['react', 'foo']);
-    expect(externals).toEqual([
-      'react',
-      'foo',
-      'react-dom',
-      'react-router',
-      'react-router-dom',
-      'history',
-      'tslib',
-      'path-to-regexp',
-      '@libre/atom',
-      '@dbeining/react-atom',
-    ]);
+    expect(externals).toEqual(['react', 'foo', 'react-dom', 'react-router', 'react-router-dom', 'history', 'tslib']);
   });
 
   it('makeExternals with explicit include and exclude', () => {
     const externals = makeExternals(process.cwd(), { piral: '*' }, ['react', 'react-calendar', '!history']);
-    expect(externals).toEqual([
-      'react',
-      'react-calendar',
-      'react-dom',
-      'react-router',
-      'react-router-dom',
-      'tslib',
-      'path-to-regexp',
-      '@libre/atom',
-      '@dbeining/react-atom',
-    ]);
+    expect(externals).toEqual(['react', 'react-calendar', 'react-dom', 'react-router', 'react-router-dom', 'tslib']);
   });
 
   it('makeExternals with all exclude and explicit include', () => {

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);
     }

package/src/common/scaffold.ts

@@ -1,10 +1,10 @@
 import { join, dirname, resolve, basename, isAbsolute } from 'path';
 import { installNpmPackage } from './npm';
-import { ForceOverwrite, SourceLanguage } from './enums';
+import { ForceOverwrite } from './enums';
 import { createDirectory, createFileIfNotExists, updateExistingJson } from './io';
 import { cliVersion, isWindows } from './info';
 import { log, fail, getLogLevel } from './log';
-import { Framework } from '../types';
+import { Framework, SourceLanguage } from '../types';
 
 interface TemplateFile {
   path: string;
@@ -103,16 +103,6 @@ function getTemplatePackageName(type: 'piral' | 'pilet', template: string) {
   return template;
 }
 
-function getLanguageName(language: SourceLanguage) {
-  switch (language) {
-    case SourceLanguage.js:
-      return 'js';
-    case SourceLanguage.ts:
-    default:
-      return 'ts';
-  }
-}
-
 export function getPiralScaffoldData(
   language: SourceLanguage,
   root: string,
@@ -125,9 +115,11 @@ export function getPiralScaffoldData(
     ...variables,
     root,
     src,
-    language: getLanguageName(language),
+    language,
     packageName,
-  };
+    reactVersion: parseInt(variables.reactVersion) || 18,
+    reactRouterVersion: parseInt(variables.reactRouterVersion) || 5,
+  } as const;
 }
 
 export async function scaffoldPiralSourceFiles(
@@ -157,9 +149,9 @@ export function getPiletScaffoldData(
     ...variables,
     root,
     src,
-    language: getLanguageName(language),
+    language,
     sourceName,
-  };
+  } as const;
 }
 
 export async function scaffoldPiletSourceFiles(