piral-cli 0.14.0-unstable.3105 → 0.14.1-beta.3246

package/src/bundler.ts

@@ -1,3 +1,4 @@
+import { callDynamic, callStatic } from './build/bundler-calls';
 import { availableBundlers } from './helpers';
 import {
   installPackage,
@@ -20,6 +21,7 @@ import {
   DebugPiletParameters,
   BundlerDefinition,
   BaseBundleParameters,
+  BaseBundlerDefinition,
 } from './types';
 
 export interface QualifiedBundler {
@@ -33,7 +35,7 @@ async function installDefaultBundler(root: string) {
   const selectedBundler = config.bundler || 'webpack';
   log('generalDebug_0003', `Installation of default bundler for "${selectedBundler}".`);
   const selectedPackage = `piral-cli-${selectedBundler}`;
-  log('generalDebug_0003', `Determining NPM client at "${root}" ...`);
+  log('generalDebug_0003', `Determining npm client at "${root}" ...`);
   const client = await determineNpmClient(root);
   log('generalDebug_0003', `Prepare to install ${selectedPackage}@${cliVersion} using "${client}" into "${root}".`);
   progress(`Installing ${selectedPackage} ...`);
@@ -76,12 +78,18 @@ async function findBundler(root: string, bundlerName?: string) {
   return defaultBundler;
 }
 
-async function prepareModules(args: BaseBundleParameters) {
+async function prepareArgs<T extends BaseBundleParameters>(bundler: BaseBundlerDefinition<T>, args: T): Promise<T> {
   if (args.optimizeModules) {
     progress('Preparing modules ...');
     await patchModules(args.root, args.ignored);
     logReset();
   }
+
+  if (bundler.prepare) {
+    return await bundler.prepare(args);
+  }
+
+  return args;
 }
 
 export function setBundler(bundler: QualifiedBundler) {
@@ -94,26 +102,52 @@ export function setBundler(bundler: QualifiedBundler) {
 
 export async function callPiralDebug(args: DebugPiralParameters, bundlerName?: string): Promise<Bundler> {
   const bundler = await findBundler(args.root, bundlerName);
-  await prepareModules(args);
-  return await bundler.actions.debugPiral.run(args).catch((err) => fail('bundlingFailed_0174', err));
+
+  try {
+    const action = bundler.actions.debugPiral;
+    const params = await prepareArgs(action, args);
+    return await callDynamic('debug-piral', action.path, params);
+  } catch (err) {
+    fail('bundlingFailed_0174', err);
+  }
 }
 
 export async function callPiletDebug(args: DebugPiletParameters, bundlerName?: string): Promise<Bundler> {
   const bundler = await findBundler(args.root, bundlerName);
-  await prepareModules(args);
-  return await bundler.actions.debugPilet.run(args).catch((err) => fail('bundlingFailed_0174', err));
+
+  try {
+    const action = bundler.actions.debugPilet;
+    const params = await prepareArgs(action, args);
+    return await callDynamic('debug-pilet', action.path, params);
+  } catch (err) {
+    fail('bundlingFailed_0174', err);
+  }
 }
 
 export async function callPiralBuild(args: BuildPiralParameters, bundlerName?: string): Promise<BundleDetails> {
   const bundler = await findBundler(args.root, bundlerName);
-  await prepareModules(args);
-  return await bundler.actions.buildPiral.run(args).catch((err) => fail('bundlingFailed_0174', err));
+
+  try {
+    const action = bundler.actions.buildPiral;
+    const params = await prepareArgs(action, args);
+    const instance = await callStatic('build-piral', action.path, params);
+    return instance.bundle;
+  } catch (err) {
+    fail('bundlingFailed_0174', err);
+  }
 }
 
 export async function callPiletBuild(args: BuildPiletParameters, bundlerName?: string): Promise<BundleDetails> {
   const bundler = await findBundler(args.root, bundlerName);
-  await prepareModules(args);
-  return await bundler.actions.buildPilet.run(args).catch((err) => fail('bundlingFailed_0174', err));
+
+  try {
+    const action = bundler.actions.buildPilet;
+    const params = await prepareArgs(action, args);
+    const instance = await callStatic('build-pilet', action.path, params);
+    return instance.bundle;
+  } catch (err) {
+    fail('bundlingFailed_0174', err);
+  }
 }
 
 export async function callDebugPiralFromMonoRepo(
@@ -121,7 +155,13 @@ export async function callDebugPiralFromMonoRepo(
   bundlerName?: string,
 ): Promise<BundleDetails> {
   const bundler = await findBundler(args.root, bundlerName);
-  await prepareModules(args);
-  const { bundle } = await bundler.actions.watchPiral.run(args).catch((err) => fail('bundlingFailed_0174', err));
-  return bundle;
+
+  try {
+    const action = bundler.actions.watchPiral;
+    const params = await prepareArgs(action, args);
+    const instance = await callStatic('debug-mono-piral', action.path, params);
+    return instance.bundle;
+  } catch (err) {
+    fail('bundlingFailed_0174', err);
+  }
 }

package/src/commands.ts

@@ -132,7 +132,10 @@ const allCommands: Array<ToolCommand<any>> = [
         .describe('source-maps', 'Create associated source maps for the bundles.')
         .default('source-maps', apps.buildPiralDefaults.sourceMaps)
         .boolean('subdir')
-        .describe('subdir', `Places the build's output in an appropriate subdirectory (e.g., "emulator"). Ignored for "--all".`)
+        .describe(
+          'subdir',
+          `Places the build's output in an appropriate subdirectory (e.g., "emulator"). Ignored for "--all".`,
+        )
         .default('subdir', apps.buildPiralDefaults.subdir)
         .boolean('content-hash')
         .describe('content-hash', 'Appends the hash to the side-bundle files.')
@@ -260,7 +263,7 @@ const allCommands: Array<ToolCommand<any>> = [
         .describe('framework', 'Sets the framework/library level to use.')
         .default('framework', apps.newPiralDefaults.framework)
         .boolean('install')
-        .describe('install', 'Already performs the installation of its NPM dependencies.')
+        .describe('install', 'Already performs the installation of its npm dependencies.')
         .default('install', apps.newPiralDefaults.install)
         .string('registry')
         .describe('registry', 'Sets the package registry to use for resolving the dependencies.')
@@ -269,7 +272,10 @@ const allCommands: Array<ToolCommand<any>> = [
         .describe('log-level', 'Sets the log level to use (1-5).')
         .default('log-level', apps.newPiralDefaults.logLevel)
         .string('tag')
-        .describe('tag', 'Sets the tag or version of the package to install. By default, this uses the version of the CLI.')
+        .describe(
+          'tag',
+          'Sets the tag or version of the package to install. By default, this uses the version of the CLI.',
+        )
         .default('tag', apps.newPiralDefaults.version)
         .choices('force-overwrite', forceOverwriteKeys)
         .describe('force-overwrite', 'Determines if files should be overwritten by the installation.')
@@ -281,7 +287,7 @@ const allCommands: Array<ToolCommand<any>> = [
         .describe('template', 'Sets the boilerplate template package to be used when scaffolding.')
         .default('template', apps.newPiralDefaults.template)
         .choices('npm-client', clientTypeKeys)
-        .describe('npm-client', 'Sets the NPM client to be used when scaffolding.')
+        .describe('npm-client', 'Sets the npm client to be used when scaffolding.')
         .default('npm-client', apps.newPiralDefaults.npmClient)
         .choices('bundler', bundlerKeys)
         .describe('bundler', 'Sets the default bundler to install.')
@@ -330,10 +336,10 @@ const allCommands: Array<ToolCommand<any>> = [
         .describe('log-level', 'Sets the log level to use (1-5).')
         .default('log-level', apps.upgradePiralDefaults.logLevel)
         .boolean('install')
-        .describe('install', 'Already performs the update of its NPM dependencies.')
+        .describe('install', 'Already performs the update of its npm dependencies.')
         .default('install', apps.upgradePiralDefaults.install)
         .choices('npm-client', clientTypeKeys)
-        .describe('npm-client', 'Sets the NPM client to be used when upgrading.')
+        .describe('npm-client', 'Sets the npm client to be used when upgrading.')
         .default('npm-client', apps.upgradePiralDefaults.npmClient)
         .string('base')
         .default('base', process.cwd())
@@ -606,7 +612,7 @@ const allCommands: Array<ToolCommand<any>> = [
         .describe('registry', 'Sets the package registry to use for resolving the specified Piral app.')
         .default('registry', apps.newPiletDefaults.registry)
         .boolean('install')
-        .describe('install', 'Already performs the installation of its NPM dependencies.')
+        .describe('install', 'Already performs the installation of its npm dependencies.')
         .default('install', apps.newPiletDefaults.install)
         .choices('force-overwrite', forceOverwriteKeys)
         .describe('force-overwrite', 'Determines if files should be overwritten by the scaffolding.')
@@ -621,7 +627,7 @@ const allCommands: Array<ToolCommand<any>> = [
         .describe('template', 'Sets the boilerplate template package to be used when scaffolding.')
         .default('template', apps.newPiletDefaults.template)
         .choices('npm-client', clientTypeKeys)
-        .describe('npm-client', 'Sets the NPM client to be used when scaffolding.')
+        .describe('npm-client', 'Sets the npm client to be used when scaffolding.')
         .default('npm-client', apps.newPiletDefaults.npmClient)
         .choices('bundler', bundlerKeys)
         .describe('bundler', 'Sets the default bundler to install.')
@@ -668,14 +674,17 @@ const allCommands: Array<ToolCommand<any>> = [
         .describe('log-level', 'Sets the log level to use (1-5).')
         .default('log-level', apps.upgradePiletDefaults.logLevel)
         .boolean('install')
-        .describe('install', 'Already performs the update of its NPM dependencies.')
+        .describe('install', 'Already performs the update of its npm dependencies.')
         .default('install', apps.upgradePiletDefaults.install)
         .choices('force-overwrite', forceOverwriteKeys)
         .describe('force-overwrite', 'Determines if files should be overwritten by the upgrading process.')
         .default('force-overwrite', keyOfForceOverwrite(apps.upgradePiletDefaults.forceOverwrite))
         .choices('npm-client', clientTypeKeys)
-        .describe('npm-client', 'Sets the NPM client to be used when upgrading.')
+        .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.');
@@ -688,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/clients/npm.ts

@@ -4,7 +4,7 @@ import { runCommand } from '../scripts';
 import { MemoryStream } from '../MemoryStream';
 
 function runNpmProcess(args: Array<string>, target: string, output?: NodeJS.WritableStream) {
-  log('generalDebug_0003', 'Starting the NPM process ...');
+  log('generalDebug_0003', 'Starting the npm process ...');
   const cwd = resolve(process.cwd(), target);
   return runCommand('npm', args, cwd, output);
 }
@@ -12,49 +12,49 @@ function runNpmProcess(args: Array<string>, target: string, output?: NodeJS.Writ
 export async function installDependencies(target = '.', ...flags: Array<string>) {
   const ms = new MemoryStream();
   await runNpmProcess(['install', '--legacy-peer-deps', ...flags], target, ms);
-  log('generalDebug_0003', `NPM install dependencies result: ${ms.value}`);
+  log('generalDebug_0003', `npm install dependencies result: ${ms.value}`);
   return ms.value;
 }
 
 export async function unpackPackage(packageRef: string, target = '.', ...flags: Array<string>) {
   const ms = new MemoryStream();
   await runNpmProcess(['pack', packageRef, ...flags], target, ms);
-  log('generalDebug_0003', `NPM (un)pack result: ${ms.value}`);
+  log('generalDebug_0003', `npm (un)pack result: ${ms.value}`);
   return ms.value;
 }
 
 export async function installPackage(packageRef: string, target = '.', ...flags: Array<string>) {
   const ms = new MemoryStream();
   await runNpmProcess(['install', packageRef, '--legacy-peer-deps', ...flags], target, ms);
-  log('generalDebug_0003', `NPM install package result: ${ms.value}`);
+  log('generalDebug_0003', `npm install package result: ${ms.value}`);
   return ms.value;
 }
 
 export async function createPackage(target = '.', ...flags: Array<string>) {
   const ms = new MemoryStream();
   await runNpmProcess(['pack', ...flags], target, ms);
-  log('generalDebug_0003', `NPM pack result: ${ms.value}`);
+  log('generalDebug_0003', `npm pack result: ${ms.value}`);
   return ms.value;
 }
 
 export async function publishPackage(target = '.', file = '*.tgz', ...flags: Array<string>) {
   const ms = new MemoryStream();
   await runNpmProcess(['publish', file, ...flags], target, ms);
-  log('generalDebug_0003', `NPM publish result: ${ms.value}`);
+  log('generalDebug_0003', `npm publish result: ${ms.value}`);
   return ms.value;
 }
 
 export async function findSpecificVersion(packageName: string, version: string) {
   const ms = new MemoryStream();
   await runNpmProcess(['show', packageName, 'version', '--tag', version], '.', ms);
-  log('generalDebug_0003', `NPM show result: ${ms.value}`);
+  log('generalDebug_0003', `npm show result: ${ms.value}`);
   return ms.value;
 }
 
 export async function findTarball(packageRef: string, target = '.', ...flags: Array<string>) {
   const ms = new MemoryStream();
   await runNpmProcess(['view', packageRef, 'dist.tarball', ...flags], target, ms);
-  log('generalDebug_0003', `NPM view packageRef result: ${ms.value}`);
+  log('generalDebug_0003', `npm view packageRef result: ${ms.value}`);
   return ms.value;
 }
 
@@ -64,9 +64,9 @@ export async function listPackage(packageRef: string, target = '.', ...flags: Ar
   try {
     await runNpmProcess(['ls', packageRef, '--json', '--depth', '0', ...flags], target, ms);
   } catch (e) {
-    log('generalDebug_0003', `NPM ls packageRef error: ${e}`);
+    log('generalDebug_0003', `npm ls packageRef error: ${e}`);
   }
 
-  log('generalDebug_0003', `NPM ls packageRef result: ${ms.value}`);
+  log('generalDebug_0003', `npm ls packageRef result: ${ms.value}`);
   return JSON.parse(ms.value);
 }

package/src/common/constants.ts

@@ -4,7 +4,7 @@ export const filesOnceTar = 'files_once';
 export const piralBaseRoot = 'piral-base/lib/types';
 export const entryModuleExtensions = ['.ts', '.tsx', '.js', '.jsx'];
 export const declarationEntryExtensions = ['.html', '.pug', ...entryModuleExtensions];
-export const coreExternals = [
+export const legacyCoreExternals = [
   '@dbeining/react-atom',
   '@libre/atom',
   'history',

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
@@ -81,6 +83,7 @@ export async function createEmulatorSources(
       ...piralPkg.dependencies,
       ...externalDependencies,
     },
+    sharedDependencies: allExternals,
     repository: piralPkg.repository,
     bugs: piralPkg.bugs,
     author: piralPkg.author,
@@ -118,7 +121,7 @@ export async function createEmulatorSources(
   // generate the associated index.d.ts
   await createPiralDeclaration(sourceDir, piralPkg.app ?? `./src/index.html`, targetDir, ForceOverwrite.yes, logLevel);
 
-  // since things like .gitignore are not properly treated by NPM we pack the files (for standard and once only)
+  // since things like .gitignore are not properly treated by npm we pack the files (for standard and once only)
   await Promise.all([
     createTarball(filesDir, rootDir, `${filesTar}.tar`),
     createTarball(filesOnceDir, rootDir, `${filesOnceTar}.tar`),

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/npm.test.ts

@@ -81,7 +81,7 @@ jest.mock('fs', () => ({
   },
 }));
 
-describe('NPM Module', () => {
+describe('npm Module', () => {
   it('dissects a fully qualified name with latest correctly', async () => {
     wrongCase = false;
     const [name, version, hadVersion, type] = await dissectPackageName(process.cwd(), 'foo@latest');
@@ -172,14 +172,14 @@ describe('NPM Module', () => {
     expect(type).toBe('registry');
   });
 
-  it('installs a package using the NPM command line tool without a target', async () => {
+  it('installs a package using the npm command line tool without a target', async () => {
     wrongCase = false;
     await installPackage('npm', 'foo', 'latest').then((result) => expect(result).toEqual(jsonValueString));
     wrongCase = true;
     await installPackage('npm', 'foo', 'latest').then((result) => expect(result).not.toEqual(jsonValueString));
   });
 
-  it('installs a package using the NPM command line tool without a version', async () => {
+  it('installs a package using the npm command line tool without a version', async () => {
     wrongCase = false;
     await installPackage('npm', 'foo').then((result) => expect(result).toEqual(jsonValueString));
     wrongCase = true;
@@ -200,7 +200,7 @@ describe('NPM Module', () => {
     await installPackage('pnpm', 'foo').then((result) => expect(result).not.toEqual(jsonValueString));
   });
 
-  it('installs a package using the NPM command line tool with some flag', async () => {
+  it('installs a package using the npm command line tool with some flag', async () => {
     wrongCase = false;
     await installPackage('npm', 'foo', '1.3', '.', '--a=b').then((result) => expect(result).toEqual(jsonValueString));
     wrongCase = true;
@@ -409,30 +409,30 @@ describe('NPM Module', () => {
   it('makeExternals without externals returns coreExternals', () => {
     const externals = makeExternals();
     expect(externals).toEqual([
-      '@dbeining/react-atom',
-      '@libre/atom',
-      'history',
       'react',
       'react-dom',
       'react-router',
       'react-router-dom',
+      'history',
       'tslib',
       'path-to-regexp',
+      '@libre/atom',
+      '@dbeining/react-atom',
     ]);
   });
 
   it('makeExternals with no externals returns coreExternals', () => {
     const externals = makeExternals([]);
     expect(externals).toEqual([
-      '@dbeining/react-atom',
-      '@libre/atom',
-      'history',
       'react',
       'react-dom',
       'react-router',
       'react-router-dom',
+      'history',
       'tslib',
       'path-to-regexp',
+      '@libre/atom',
+      '@dbeining/react-atom',
     ]);
   });
 
@@ -446,15 +446,15 @@ describe('NPM Module', () => {
     expect(externals).toEqual([
       'foo',
       'bar',
-      '@dbeining/react-atom',
-      '@libre/atom',
-      'history',
       'react',
       'react-dom',
       'react-router',
       'react-router-dom',
+      'history',
       'tslib',
       'path-to-regexp',
+      '@libre/atom',
+      '@dbeining/react-atom',
     ]);
   });
 
@@ -463,14 +463,14 @@ describe('NPM Module', () => {
     expect(externals).toEqual([
       'react',
       'foo',
-      '@dbeining/react-atom',
-      '@libre/atom',
-      'history',
       'react-dom',
       'react-router',
       'react-router-dom',
+      'history',
       'tslib',
       'path-to-regexp',
+      '@libre/atom',
+      '@dbeining/react-atom',
     ]);
   });
 
@@ -479,13 +479,13 @@ describe('NPM Module', () => {
     expect(externals).toEqual([
       'react',
       'react-calendar',
-      '@dbeining/react-atom',
-      '@libre/atom',
       'react-dom',
       'react-router',
       'react-router-dom',
       'tslib',
       'path-to-regexp',
+      '@libre/atom',
+      '@dbeining/react-atom',
     ]);
   });
 

package/src/common/npm.ts

@@ -2,8 +2,8 @@ import { resolve, relative } from 'path';
 import { createReadStream, existsSync, access, constants } from 'fs';
 import { log, fail } from './log';
 import { config } from './config';
+import { legacyCoreExternals } from './constants';
 import { inspectPackage } from './inspect';
-import { coreExternals } from './constants';
 import { readJson, checkExists, findFile } from './io';
 import { clientTypeKeys } from '../helpers';
 import { PackageType, NpmClientType } from '../types';
@@ -69,27 +69,27 @@ export async function getLernaNpmClient(root: string): Promise<NpmClientType> {
  */
 export async function determineNpmClient(root: string, selected?: NpmClientType): Promise<NpmClientType> {
   if (!selected || !clientTypeKeys.includes(selected)) {
-    log('generalDebug_0003', 'No NPM client selected. Checking for lock files ...');
+    log('generalDebug_0003', 'No npm client selected. Checking for lock files ...');
     const [hasNpm, hasYarn, hasPnpm] = await Promise.all([detectNpm(root), detectYarn(root), detectPnpm(root)]);
     const found = +hasNpm + +hasYarn + +hasPnpm;
-    log('generalDebug_0003', `Results of the lock file check: NPM = ${hasNpm}, Yarn = ${hasYarn}, Pnpm = ${hasPnpm}`);
+    log('generalDebug_0003', `Results of the lock file check: npm = ${hasNpm}, Yarn = ${hasYarn}, Pnpm = ${hasPnpm}`);
     const defaultClient = config.npmClient;
 
     if (found !== 1) {
       const lernaClient = await getLernaNpmClient(root);
 
       if (clientTypeKeys.includes(lernaClient)) {
-        log('generalDebug_0003', `Found valid NPM client via Lerna: ${lernaClient}.`);
+        log('generalDebug_0003', `Found valid npm client via Lerna: ${lernaClient}.`);
         return lernaClient;
       }
     } else if (hasNpm) {
-      log('generalDebug_0003', `Found valid NPM client via lockfile.`);
+      log('generalDebug_0003', `Found valid npm client via lockfile.`);
       return 'npm';
     } else if (hasYarn) {
       log('generalDebug_0003', `Found valid Yarn client via lockfile.`);
       return 'yarn';
     } else if (hasPnpm) {
-      log('generalDebug_0003', `Found valid Pnpm client via lockfile.`);
+      log('generalDebug_0003', `Found valid pnpm client via lockfile.`);
       return 'pnpm';
     }
 
@@ -98,7 +98,7 @@ export async function determineNpmClient(root: string, selected?: NpmClientType)
       return defaultClient;
     }
 
-    log('generalDebug_0003', 'Using the default NPM client.');
+    log('generalDebug_0003', 'Using the default npm client.');
     return 'npm';
   }
 
@@ -388,7 +388,26 @@ export function getPackageVersion(
   }
 }
 
-export function makeExternals(externals?: Array<string>) {
+export function getCoreExternals(): Array<string> {
+  try {
+    return require('piral-core/package.json').sharedDependencies || [];
+  } catch {
+    return [];
+  }
+}
+
+export function makePiletExternals(externals: Array<string>, fromEmulator: boolean, piralInfo: any) {
+  if (fromEmulator) {
+    const { sharedDependencies = makeExternals(externals, true) } = piralInfo;
+    return sharedDependencies;
+  } else {
+    return makeExternals(externals);
+  }
+}
+
+export function makeExternals(externals?: Array<string>, legacy = false) {
+  const coreExternals = legacy ? legacyCoreExternals : getCoreExternals();
+
   if (externals && Array.isArray(externals)) {
     const [include, exclude] = externals.reduce<[Array<string>, Array<string>]>(
       (prev, curr) => {