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

package/src/common/language.ts

@@ -1,45 +1,100 @@
 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 reactRouter6Typings = {
+  '@types/react-router': '^6',
+  '@types/react-router-dom': '^6',
+};
+
+const defaultDeps = {};
+
+const defaultTypings = {
+  '@types/react': '*',
+  '@types/react-dom': '*',
+  '@types/react-router': '*',
+  '@types/react-router-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 : reactRouter6Typings),
+      };
+}
+
+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/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) || 17,
+    reactRouterVersion: parseInt(variables.reactRouterVersion) || 17,
+  } 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(

package/src/common/template.ts

@@ -1,53 +1,32 @@
-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();
-      }
-    });
-  });
-}
+function fillTemplate(data: any = {}) {
+  return `if (process.env.NODE_ENV === 'test') {
+  // behavior for the test environment, we'll try to make it work
 
-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}".`);
-    renderFile(path, data, (err, str) => {
-      if (err) {
-        reject(err);
-      } else {
-        resolve(str);
-      }
-    });
-  });
+  if (typeof window !== 'undefined') {
+    require('./${data.outFile}');
+    const ctx = window['dbg:piral'];
+    const dependencies = (ctx && ctx.pilets && ctx.pilets.getDependencies({})) || {};
+    module.exports = dependencies['${data.name}'] || {};
+  } else {
+    console.error('Your test environment does not define "window". Please make sure to provide a proper environment.');
+    module.exports = {};
+  }
+} else {
+  // under "normal" circumstances disallow such an import
+  throw new Error("This file should not be included anywhere. Usually, this means you've imported the Piral instance directly.");
+}
+`;
 }
 
-export async function createFileFromTemplateIfNotExists(
-  prefix: string,
+export async function createPiralStubIndexIfNotExists(
   targetDir: string,
   fileName: string,
   forceOverwrite?: ForceOverwrite,
   data?: any,
 ) {
-  const content = await fillTemplate(`${prefix}-${fileName}`, data);
+  const content = fillTemplate(data);
   await createFileIfNotExists(targetDir, fileName, content, forceOverwrite);
 }

package/src/helpers.test.ts

@@ -1,5 +1,5 @@
-import { keyOfForceOverwrite, keyOfSourceLanguage, valueOfForceOverwrite, valueOfSourceLanguage } from './helpers';
-import { ForceOverwrite, SourceLanguage } from './common/enums';
+import { keyOfForceOverwrite, valueOfForceOverwrite } from './helpers';
+import { ForceOverwrite } from './common/enums';
 
 describe('Piral CLI Command Helpers Module', () => {
   it('correct value of keyOfForceOverwrite results in same key', () => {
@@ -12,16 +12,6 @@ describe('Piral CLI Command Helpers Module', () => {
     expect(result).toBe('no');
   });
 
-  it('correct value of keyOfPiletLanguage results in same key', () => {
-    const result = keyOfSourceLanguage(SourceLanguage.ts);
-    expect(result).toBe('ts');
-  });
-
-  it('incorrect value of keyOfPiletLanguage results in key for TS', () => {
-    const result = keyOfSourceLanguage(5);
-    expect(result).toBe('ts');
-  });
-
   it('correct key of valueOfForceOverwrite results in same value', () => {
     const result = valueOfForceOverwrite('prompt');
     expect(result).toBe(ForceOverwrite.prompt);
@@ -31,14 +21,4 @@ describe('Piral CLI Command Helpers Module', () => {
     const result = valueOfForceOverwrite('foo');
     expect(result).toBe(ForceOverwrite.no);
   });
-
-  it('correct key of valueOfPiletLanguage results in same value', () => {
-    const result = valueOfSourceLanguage('ts');
-    expect(result).toBe(SourceLanguage.ts);
-  });
-
-  it('incorrect key of valueOfPiletLanguage results in value for TS', () => {
-    const result = valueOfSourceLanguage('foo');
-    expect(result).toBe(SourceLanguage.ts);
-  });
 });

package/src/helpers.ts

@@ -1,4 +1,4 @@
-import { ForceOverwrite, SourceLanguage } from './common/enums';
+import { ForceOverwrite } from './common/enums';
 import { bundlerNames, frameworkLibs } from './common/constants';
 import type {
   Framework,
@@ -8,6 +8,7 @@ import type {
   PiralBuildType,
   PiletBuildType,
   PiletPublishScheme,
+  SourceLanguage,
 } from './types';
 
 export const schemaKeys: Array<PiletSchemaVersion> = ['v0', 'v1', 'v2', 'none'];
@@ -16,6 +17,7 @@ export const fromKeys: Array<PiletPublishSource> = ['local', 'remote', 'npm'];
 export const piralBuildTypeKeys: Array<PiralBuildType> = ['all', 'release', 'emulator', 'emulator-sources'];
 export const piletBuildTypeKeys: Array<PiletBuildType> = ['default', 'standalone', 'manifest'];
 export const clientTypeKeys: Array<NpmClientType> = ['npm', 'pnpm', 'pnp', 'yarn', 'lerna', 'rush'];
+export const sourceLanguageKeys: Array<SourceLanguage> = ['ts', 'js'];
 export const bundlerKeys: Array<string> = ['none', ...bundlerNames];
 export const availableBundlers: Array<string> = [];
 export const availableReleaseProviders: Array<string> = [];
@@ -41,25 +43,3 @@ export function keyOfForceOverwrite(value: ForceOverwrite) {
 
   return forceOverwriteKeys[0];
 }
-
-export const sourceLanguageKeys = Object.keys(SourceLanguage).filter((m) => typeof SourceLanguage[m] === 'number');
-
-export function valueOfSourceLanguage(key: string): SourceLanguage {
-  for (const piletLanguageKey of sourceLanguageKeys) {
-    if (piletLanguageKey === key) {
-      return SourceLanguage[piletLanguageKey];
-    }
-  }
-
-  return SourceLanguage.ts;
-}
-
-export function keyOfSourceLanguage(value: SourceLanguage) {
-  for (const piletLanguageKey of sourceLanguageKeys) {
-    if (SourceLanguage[piletLanguageKey] === value) {
-      return piletLanguageKey;
-    }
-  }
-
-  return sourceLanguageKeys[0];
-}

package/src/types/common.ts

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

package/src/types/public.ts

@@ -219,6 +219,8 @@ export interface BundlerDefinition {
 
 export type PiletSchemaVersion = 'none' | 'v0' | 'v1' | 'v2';
 
+export type SourceLanguage = 'js' | 'ts';
+
 export type PiletPublishScheme = 'none' | 'digest' | 'bearer' | 'basic';
 
 export type PiletPublishSource = 'local' | 'npm' | 'remote';

package/templates/piral-index.js.ejs

@@ -1,16 +0,0 @@
-if (process.env.NODE_ENV === 'test') {
-  // behavior for the test environment, we'll try to make it work
-
-  if (typeof window !== 'undefined') {
-    require('./<%- outFile %>');
-    const ctx = window['dbg:piral'];
-    const dependencies = (ctx && ctx.pilets && ctx.pilets.getDependencies({})) || {};
-    module.exports = dependencies['<%- name %>'] || {};
-  } else {
-    console.error('Your test environment does not define "window". Please make sure to provide a proper environment.');
-    module.exports = {};
-  }
-} else {
-  // under "normal" circumstances disallow such an import
-  throw new Error("This file should not be included anywhere. Usually, this means you've imported the Piral instance directly.");
-}