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

package/src/apps/build-piral.ts

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

package/src/apps/debug-pilet.ts

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

package/src/apps/debug-piral.ts

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

package/src/apps/new-pilet.ts

@@ -30,6 +30,7 @@ import {
   getPiralPath,
   detectMonorepo,
   bootstrapMonorepo,
+  getPiletScaffoldData,
 } from '../common';
 
 export interface NewPiletOptions {
@@ -76,7 +77,7 @@ export interface NewPiletOptions {
   logLevel?: LogLevels;
 
   /**
-   * The NPM client to be used when scaffolding.
+   * The npm client to be used when scaffolding.
    * @example 'yarn'
    */
   npmClient?: NpmClientType;
@@ -154,7 +155,7 @@ export async function newPilet(baseDir = process.cwd(), options: NewPiletOptions
     );
 
     if (registry !== newPiletDefaults.registry) {
-      progress(`Setting up NPM registry (%s) ...`, registry);
+      progress(`Setting up npm registry (%s) ...`, registry);
 
       await createFileIfNotExists(
         root,
@@ -170,11 +171,11 @@ always-auth=true`,
     if (!isLocal) {
       const packageRef = combinePackageRef(sourceName, sourceVersion, type);
 
-      progress(`Installing NPM package %s ...`, packageRef);
+      progress(`Installing npm package %s ...`, packageRef);
 
       await installPackage(npmClient, packageRef, root, '--save-dev');
     } else {
-      progress(`Using locally available NPM package %s ...`, sourceName);
+      progress(`Using locally available npm package %s ...`, sourceName);
     }
 
     const packageName = await getPackageName(root, sourceName, type);
@@ -193,19 +194,23 @@ always-auth=true`,
 
     progress(`Taking care of templating ...`);
 
-    await scaffoldPiletSourceFiles(template, registry, language, root, packageName, forceOverwrite, variables);
+    const data = getPiletScaffoldData(language, root, packageName, variables);
+    await scaffoldPiletSourceFiles(template, registry, data, forceOverwrite);
 
     if (isEmulator) {
       // in the emulator case we get the files (and files_once) from the contained tarballs
-      await copyPiralFiles(root, packageName, piralInfo, ForceOverwrite.yes);
+      await copyPiralFiles(root, packageName, piralInfo, ForceOverwrite.yes, data);
     } else {
       // otherwise, we perform the same action as in the emulator creation
       // just with a different target; not a created directory, but the root
       const packageRoot = getPiralPath(root, packageName);
-      await copyScaffoldingFiles(packageRoot, root, files, piralInfo);
+      await copyScaffoldingFiles(packageRoot, root, files, piralInfo, data);
     }
 
-    await patchPiletPackage(root, packageName, packageVersion, piralInfo, { language, bundler: bundlerName });
+    await patchPiletPackage(root, packageName, packageVersion, piralInfo, isEmulator, {
+      language,
+      bundler: bundlerName,
+    });
 
     if (install) {
       progress(`Installing dependencies ...`);

package/src/apps/new-piral.ts

@@ -18,6 +18,7 @@ import {
   determineNpmClient,
   defaultRegistry,
   cliVersion,
+  getPiralScaffoldData,
 } from '../common';
 
 export interface NewPiralOptions {
@@ -72,7 +73,7 @@ export interface NewPiralOptions {
   logLevel?: LogLevels;
 
   /**
-   * Sets the NPM client to be used when scaffolding. (e.g. 'yarn')
+   * Sets the npm client to be used when scaffolding. (e.g. 'yarn')
    */
   npmClient?: NpmClientType;
 
@@ -148,7 +149,7 @@ export async function newPiral(baseDir = process.cwd(), options: NewPiralOptions
     );
 
     if (registry !== newPiralDefaults.registry) {
-      progress(`Setting up NPM registry (%s) ...`, registry);
+      progress(`Setting up npm registry (%s) ...`, registry);
 
       await createFileIfNotExists(
         root,
@@ -161,13 +162,14 @@ always-auth=true`,
 
     await updateExistingJson(root, 'package.json', getPiralPackage(app, language, version, framework, bundlerName));
 
-    progress(`Installing NPM package ${packageRef} ...`);
+    progress(`Installing npm package ${packageRef} ...`);
 
     await installPackage(npmClient, packageRef, root);
 
     progress(`Taking care of templating ...`);
-
-    await scaffoldPiralSourceFiles(template, registry, language, root, app, framework, forceOverwrite, variables);
+    
+    const data = getPiralScaffoldData(language, root, app, framework, variables);
+    await scaffoldPiralSourceFiles(template, registry, data, forceOverwrite);
 
     if (install) {
       progress(`Installing dependencies ...`);

package/src/apps/pack-pilet.test.ts

@@ -8,7 +8,7 @@ function createTempDir() {
 }
 
 describe('Pack Pilet Command', () => {
-  it('can pack a standard NPM package to a specified target', async () => {
+  it('can pack a standard npm package to a specified target', async () => {
     const dir = createTempDir();
     const target = 'foo.tgz';
     const packageJson = resolve(dir, 'package.json');
@@ -28,7 +28,7 @@ describe('Pack Pilet Command', () => {
     expect(existsSync(resolve(dir, target))).toBeTruthy();
   });
 
-  it('can pack a standard NPM package to a the default target using the process directory', async () => {
+  it('can pack a standard npm package to a the default target using the process directory', async () => {
     const originalDir = process.cwd();
     const dir = createTempDir();
     const packageJson = resolve(dir, 'package.json');

package/src/apps/pack-pilet.ts

@@ -10,7 +10,7 @@ export interface PackPiletOptions {
 
 export const packPiletDefaults: PackPiletOptions = {
   /**
-   * Sets the source directory for creating the NPM package.
+   * Sets the source directory for creating the npm package.
    */
   source: '.',
 

package/src/apps/publish-pilet.ts

@@ -59,7 +59,7 @@ export interface PublishPiletOptions {
   /**
    * Changing the publish source makes it possible to publish pilets that have
    * been stored on non-local paths, e.g., when a pilet was already published to
-   * an NPM feed.
+   * an npm feed.
    */
   from?: PiletPublishSource;
 
@@ -114,7 +114,7 @@ async function getFiles(
         log('generalDebug_0003', `Download file from "${source}".`);
         return await downloadFile(source, ca);
       case 'npm':
-        log('generalDebug_0003', `View NPM package "${source}".`);
+        log('generalDebug_0003', `View npm package "${source}".`);
         const url = await findTarball(source);
         log('generalDebug_0003', `Download file from "${url}".`);
         return await downloadFile(url, ca);

package/src/apps/upgrade-pilet.ts

@@ -25,6 +25,8 @@ import {
   detectMonorepo,
   bootstrapMonorepo,
   isMonorepoPackageRef,
+  getPiletScaffoldData,
+  SourceLanguage,
 } from '../common';
 
 export interface UpgradePiletOptions {
@@ -58,11 +60,16 @@ export interface UpgradePiletOptions {
   install?: boolean;
 
   /**
-   * Defines the used NPM client. By default, "npm" is used
+   * Defines the used npm client. By default, "npm" is used
    * if no other client is autodetected. The autodetection
-   * works against Lerna, PNPM, and Yarn.
+   * works against Lerna, pnpm, and Yarn.
    */
   npmClient?: NpmClientType;
+
+  /**
+   * Places additional variables that should used when scaffolding.
+   */
+  variables?: Record<string, string>;
 }
 
 export const upgradePiletDefaults: UpgradePiletOptions = {
@@ -72,6 +79,7 @@ export const upgradePiletDefaults: UpgradePiletOptions = {
   logLevel: LogLevels.info,
   install: true,
   npmClient: undefined,
+  variables: {},
 };
 
 export async function upgradePilet(baseDir = process.cwd(), options: UpgradePiletOptions = {}) {
@@ -81,6 +89,7 @@ export async function upgradePilet(baseDir = process.cwd(), options: UpgradePile
     forceOverwrite = upgradePiletDefaults.forceOverwrite,
     logLevel = upgradePiletDefaults.logLevel,
     install = upgradePiletDefaults.install,
+    variables = upgradePiletDefaults.variables,
   } = options;
   const fullBase = resolve(process.cwd(), baseDir);
   const root = resolve(fullBase, target);
@@ -93,10 +102,11 @@ export async function upgradePilet(baseDir = process.cwd(), options: UpgradePile
 
   const npmClient = await determineNpmClient(root, options.npmClient);
   const pckg = await readJson(root, 'package.json');
-  const { devDependencies = {}, dependencies = {}, piral } = pckg;
+  const { devDependencies = {}, dependencies = {}, piral, source } = pckg;
 
   if (piral && typeof piral === 'object') {
     const sourceName = piral.name;
+    const language = /\.jsx?$/.test(source) ? SourceLanguage.js : SourceLanguage.ts;
 
     if (!sourceName || typeof sourceName !== 'string') {
       fail('invalidPiletPackage_0042');
@@ -120,7 +130,7 @@ export async function upgradePilet(baseDir = process.cwd(), options: UpgradePile
 
     if (!monorepoRef) {
       // only install the latest if the shell does come from remote
-      progress(`Updating NPM package to %s ...`, packageRef);
+      progress(`Updating npm package to %s ...`, packageRef);
       await installPackage(npmClient, packageRef, root, '--no-save');
     }
 
@@ -137,19 +147,20 @@ export async function upgradePilet(baseDir = process.cwd(), options: UpgradePile
     }
 
     progress(`Taking care of templating ...`);
+    const data = getPiletScaffoldData(language, root, sourceName, variables);
 
     if (isEmulator) {
       // in the emulator case we get the files from the contained tarball
-      await copyPiralFiles(root, sourceName, piralInfo, forceOverwrite, originalFiles);
+      await copyPiralFiles(root, sourceName, piralInfo, forceOverwrite, data, originalFiles);
     } else {
       // otherwise, we perform the same action as in the emulator creation
       // just with a different target; not a created directory, but the root
       const packageRoot = getPiralPath(root, sourceName);
       const notOnceFiles = files.filter((m) => typeof m === 'string' || !m.once);
-      await copyScaffoldingFiles(packageRoot, root, notOnceFiles, piralInfo);
+      await copyScaffoldingFiles(packageRoot, root, notOnceFiles, piralInfo, data);
     }
 
-    await patchPiletPackage(root, sourceName, packageVersion, piralInfo);
+    await patchPiletPackage(root, sourceName, packageVersion, piralInfo, isEmulator);
 
     if (install) {
       progress(`Updating dependencies ...`);

package/src/apps/upgrade-piral.ts

@@ -42,9 +42,9 @@ export interface UpgradePiralOptions {
   install?: boolean;
 
   /**
-   * Defines the used NPM client. By default, "npm" is used
+   * Defines the used npm client. By default, "npm" is used
    * if no other client is autodetected. The autodetection
-   * works against Lerna, PNPM, and Yarn.
+   * works against Lerna, pnpm, and Yarn.
    */
   npmClient?: NpmClientType;
 }
@@ -112,7 +112,7 @@ export async function upgradePiral(baseDir = process.cwd(), options: UpgradePira
   await updateExistingJson(root, 'package.json', pckg);
 
   if (install) {
-    progress(`Updating the NPM packages to %s ...`, version);
+    progress(`Updating the npm packages to %s ...`, version);
     await installDependencies(npmClient, root);
   }
 

package/src/build/bundler-calls.ts

@@ -0,0 +1,121 @@
+import { resolve } from 'path';
+import { fork, ChildProcess } from 'child_process';
+import { Bundler, BundleDetails, BaseBundleParameters } from '../types';
+
+function getPath(name: string) {
+  return resolve(__dirname, '..', '..', 'lib', 'build', `run-${name}.js`);
+}
+
+type BundleListener = (args: any) => void;
+
+function createBundler(cwd: string, ps: ChildProcess, args: any) {
+  let promise = Promise.resolve();
+  const listeners: Array<BundleListener> = [];
+  const bundle: BundleDetails = {
+    dir: cwd,
+    hash: '',
+    name: '',
+  };
+  const setPending = () => {
+    promise = new Promise((done) => {
+      const f = () => {
+        done();
+        bundler.off(f);
+      };
+      bundler.on(f);
+    });
+  };
+  const bundler = {
+    bundle,
+    start() {
+      ps.send({
+        type: 'bundle',
+        ...args,
+      });
+    },
+    on(cb: BundleListener) {
+      listeners.push(cb);
+    },
+    off(cb: BundleListener) {
+      listeners.splice(listeners.indexOf(cb), 1);
+    },
+    emit(args: any) {
+      [...listeners].forEach((cb) => cb(args));
+    },
+    ready() {
+      return promise;
+    },
+    setPending,
+  };
+  setPending();
+  return bundler;
+}
+
+export function callDynamic<T extends BaseBundleParameters>(name: string, path: string, args: T) {
+  const cwd = args.root;
+  return new Promise<Bundler>((resolve, reject) => {
+    const ps = fork(getPath(name), [], { cwd });
+    const bundler = createBundler(cwd, ps, args);
+    const setup = {
+      type: 'init',
+      path,
+    };
+    const start = () => {
+      ps.send({
+        type: 'start',
+        ...args,
+      });
+    };
+
+    ps.on('message', (msg: any) => {
+      switch (msg.type) {
+        case 'pending':
+          bundler.setPending();
+          break;
+        case 'update':
+          bundler.bundle.hash = msg.outHash;
+          bundler.bundle.name = msg.outName;
+          bundler.emit(msg.args);
+          break;
+        case 'done':
+          bundler.bundle.dir = msg.outDir;
+          return resolve(bundler);
+        case 'fail':
+          return reject(msg.error);
+      }
+    });
+
+    ps.send(setup, start);
+  });
+}
+
+export function callStatic<T extends BaseBundleParameters>(name: string, path: string, args: T) {
+  const cwd = args.root;
+  return new Promise<Bundler>((resolve, reject) => {
+    const ps = fork(getPath(name), [], { cwd });
+    const bundler = createBundler(cwd, ps, args);
+    const setup = {
+      type: 'init',
+      path,
+    };
+    const start = () => {
+      ps.send({
+        type: 'start',
+        ...args,
+      });
+    };
+
+    ps.on('message', (msg: any) => {
+      switch (msg.type) {
+        case 'done':
+          bundler.bundle.dir = msg.outDir;
+          bundler.bundle.name = msg.outFile;
+          return resolve(bundler);
+        case 'fail':
+          return reject(msg.error);
+      }
+    });
+
+    ps.send(setup, start);
+  });
+}