piral-cli 0.15.0-beta.4633 → 0.15.0-beta.4672

package/src/apps/debug-pilet.ts

@@ -22,6 +22,7 @@ import {
   createInitialKrasConfig,
   getAvailablePort,
   combinePiletExternals,
+  watcherTask,
 } from '../common';
 
 export interface DebugPiletOptions {
@@ -216,131 +217,148 @@ export async function debugPilet(baseDir = process.cwd(), options: DebugPiletOpt
   } = options;
   const publicUrl = normalizePublicUrl(originalPublicUrl);
   const fullBase = resolve(process.cwd(), baseDir);
+  const port = await getAvailablePort(originalPort);
   setLogLevel(logLevel);
 
   await hooks.onBegin?.({ options, fullBase });
-  progress('Reading configuration ...');
-  const api = `${publicUrl}${config.piletApi.replace(/^\/+/, '')}`;
-  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 "${fullBase}".`);
-
-  const allEntries = await matchAnyPilet(fullBase, entryList);
-  const maxListeners = Math.max(2 + allEntries.length * 2, 16);
-  log('generalDebug_0003', `Found the following entries: ${allEntries.join(', ')}`);
-
-  if (allEntries.length === 0) {
-    fail('entryFileMissing_0077');
-  }
 
-  process.stderr.setMaxListeners(maxListeners);
-  process.stdout.setMaxListeners(maxListeners);
-  process.stdin.setMaxListeners(maxListeners);
-
-  const pilets = await concurrentWorkers(allEntries, concurrency, async (entryModule) => {
-    const targetDir = dirname(entryModule);
-    const { peerDependencies, peerModules, root, apps, ignored, importmap } = await retrievePiletData(targetDir, app);
-    const piralInstances = apps.map((m) => m.appPackage.name);
-    const externals = combinePiletExternals(piralInstances, peerDependencies, peerModules, importmap);
-    const mocks = join(targetDir, 'mocks');
-    const dest = resolve(root, target);
-    const outDir = dirname(dest);
-    const outFile = basename(dest);
-    const mocksExists = await checkExistingDirectory(mocks);
-
-    await hooks.beforeBuild?.({ root, publicUrl, importmap, entryModule, schemaVersion });
-
-    const bundler = await callPiletDebug(
-      {
-        root,
-        piralInstances,
-        optimizeModules,
-        hmr,
-        externals,
-        targetDir,
-        importmap,
-        outFile,
-        outDir,
-        entryModule: `./${relative(root, entryModule)}`,
-        logLevel,
-        version: schemaVersion,
-        ignored,
-        _,
-      },
-      bundlerName,
+  await watcherTask(async (watcherContext) => {
+    progress('Reading configuration ...');
+    const api = `${publicUrl}${config.piletApi.replace(/^\/+/, '')}`;
+    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 "${fullBase}".`,
     );
 
-    bundler.on((args) => {
-      hooks.afterBuild?.({ ...args, root, publicUrl, importmap, entryModule, schemaVersion, bundler, outFile, outDir });
-    });
-
-    return {
-      apps,
-      publicUrl,
-      externals,
-      bundler,
-      mocks: mocksExists ? mocks : undefined,
-      root,
-    };
-  });
+    const allEntries = await matchAnyPilet(fullBase, entryList);
+    const maxListeners = Math.max(2 + allEntries.length * 2, 16);
+    log('generalDebug_0003', `Found the following entries: ${allEntries.join(', ')}`);
 
-  // sanity check see #250
-  checkSanity(pilets);
+    if (allEntries.length === 0) {
+      fail('entryFileMissing_0077');
+    }
 
-  await hooks.beforeApp?.({ appInstanceDir, pilets });
-  const appDirs = [appInstanceDir] || (await getOrMakeApps(pilets[0], logLevel));
+    process.stderr.setMaxListeners(maxListeners);
+    process.stdout.setMaxListeners(maxListeners);
+    process.stdin.setMaxListeners(maxListeners);
+
+    const pilets = await concurrentWorkers(allEntries, concurrency, async (entryModule) => {
+      const targetDir = dirname(entryModule);
+      const { peerDependencies, peerModules, root, apps, ignored, importmap } = await retrievePiletData(targetDir, app);
+      const piralInstances = apps.map((m) => m.appPackage.name);
+      const externals = combinePiletExternals(piralInstances, peerDependencies, peerModules, importmap);
+      const mocks = join(targetDir, 'mocks');
+      const dest = resolve(root, target);
+      const outDir = dirname(dest);
+      const outFile = basename(dest);
+      const mocksExists = await checkExistingDirectory(mocks);
+
+      await hooks.beforeBuild?.({ root, publicUrl, importmap, entryModule, schemaVersion });
+
+      const bundler = await callPiletDebug(
+        {
+          root,
+          piralInstances,
+          optimizeModules,
+          hmr,
+          externals,
+          targetDir,
+          importmap,
+          outFile,
+          outDir,
+          entryModule: `./${relative(root, entryModule)}`,
+          logLevel,
+          version: schemaVersion,
+          ignored,
+          _,
+        },
+        bundlerName,
+      );
 
-  await Promise.all(
-    appDirs.map(async (appDir) => {
-      const appRoot = dirname(await findFile(appDir, 'package.json'));
-      await hooks.afterApp?.({ appInstanceDir, pilets });
+      bundler.on((args) => {
+        hooks.afterBuild?.({
+          ...args,
+          root,
+          publicUrl,
+          importmap,
+          entryModule,
+          schemaVersion,
+          bundler,
+          outFile,
+          outDir,
+        });
+      });
 
-      Promise.all(pilets.map((p) => p.bundler.ready())).then(() => logDone(`Ready!`));
+      return {
+        apps,
+        publicUrl,
+        externals,
+        bundler,
+        mocks: mocksExists ? mocks : undefined,
+        root,
+      };
+    });
 
-      const sources = pilets.map((m) => m.mocks).filter(Boolean);
-      const baseMocks = resolve(fullBase, 'mocks');
-      const krasBaseConfig = resolve(fullBase, krasrc);
-      const krasRootConfig = resolve(appRoot, krasrc);
-      const initial = createInitialKrasConfig(baseMocks, sources, { [api]: '' }, feed);
-      const required = {
-        injectors: {
-          piral: {
-            active: false,
+    // sanity check see #250
+    checkSanity(pilets);
+
+    await hooks.beforeApp?.({ appInstanceDir, pilets });
+    const appDirs = [appInstanceDir] || (await getOrMakeApps(pilets[0], logLevel));
+
+    await Promise.all(
+      appDirs.map(async (appDir) => {
+        const appRoot = dirname(await findFile(appDir, 'package.json'));
+        await hooks.afterApp?.({ appInstanceDir, pilets });
+
+        Promise.all(pilets.map((p) => p.bundler.ready())).then(() => logDone(`Ready!`));
+
+        const sources = pilets.map((m) => m.mocks).filter(Boolean);
+        const baseMocks = resolve(fullBase, 'mocks');
+        const krasBaseConfig = resolve(fullBase, krasrc);
+        const krasRootConfig = resolve(appRoot, krasrc);
+        const initial = createInitialKrasConfig(baseMocks, sources, { [api]: '' }, feed);
+        const required = {
+          injectors: {
+            piral: {
+              active: false,
+            },
+            pilet: {
+              active: true,
+              pilets,
+              app: appDir,
+              publicUrl,
+              handle: ['/', api],
+              api,
+            },
           },
-          pilet: {
-            active: true,
-            pilets,
-            app: appDir,
+        };
+        const configs = [krasBaseConfig, ...pilets.map((p) => resolve(p.root, krasrc)), krasRootConfig];
+        const krasConfig = readKrasConfig({ port, initial, required }, ...configs);
+
+        log('generalVerbose_0004', `Using kras with configuration: ${JSON.stringify(krasConfig, undefined, 2)}`);
+
+        const krasServer = buildKrasWithCli(krasConfig);
+        krasServer.setMaxListeners(maxListeners);
+        krasServer.removeAllListeners('open');
+        krasServer.on(
+          'open',
+          notifyServerOnline(
+            pilets.map((p) => p.bundler),
             publicUrl,
-            handle: ['/', api],
-            api,
-          },
-        },
-      };
-      const configs = [krasBaseConfig, ...pilets.map((p) => resolve(p.root, krasrc)), krasRootConfig];
-      const port = await getAvailablePort(originalPort);
-      const krasConfig = readKrasConfig({ port, initial, required }, ...configs);
-
-      log('generalVerbose_0004', `Using kras with configuration: ${JSON.stringify(krasConfig, undefined, 2)}`);
-
-      const krasServer = buildKrasWithCli(krasConfig);
-      krasServer.setMaxListeners(maxListeners);
-      krasServer.removeAllListeners('open');
-      krasServer.on(
-        'open',
-        notifyServerOnline(
-          pilets.map((p) => p.bundler),
-          publicUrl,
-          krasConfig.api,
-        ),
-      );
+            krasConfig.api,
+          ),
+        );
+
+        await hooks.beforeOnline?.({ krasServer, krasConfig, open, port, api, feed, pilets, publicUrl });
+        await krasServer.start();
+        openBrowser(open, port, publicUrl, !!krasConfig.ssl);
+        await hooks.afterOnline?.({ krasServer, krasConfig, open, port, api, feed, pilets, publicUrl });
+        await new Promise((resolve) => krasServer.on('close', resolve));
+      }),
+    );
+  });
 
-      await hooks.beforeOnline?.({ krasServer, krasConfig, open, port, api, feed, pilets, publicUrl });
-      await krasServer.start();
-      openBrowser(open, port, publicUrl, !!krasConfig.ssl);
-      await hooks.afterOnline?.({ krasServer, krasConfig, open, port, api, feed, pilets, publicUrl });
-      await new Promise((resolve) => krasServer.on('close', resolve));
-      await hooks.onEnd?.({});
-    }),
-  );
+  await hooks.onEnd?.({});
 }

package/src/apps/debug-piral.ts

@@ -18,6 +18,7 @@ import {
   createInitialKrasConfig,
   getAvailablePort,
   checkExistingDirectory,
+  watcherTask,
 } from '../common';
 
 export interface DebugPiralOptions {
@@ -118,77 +119,83 @@ export async function debugPiral(baseDir = process.cwd(), options: DebugPiralOpt
   } = options;
   const publicUrl = normalizePublicUrl(originalPublicUrl);
   const fullBase = resolve(process.cwd(), baseDir);
+  const port = await getAvailablePort(originalPort);
   setLogLevel(logLevel);
 
   await hooks.onBegin?.({ options, fullBase });
-  progress('Reading configuration ...');
-  const entryFiles = await retrievePiralRoot(fullBase, entry);
-  const targetDir = dirname(entryFiles);
-  const { externals, name, root, ignored } = await retrievePiletsInfo(entryFiles);
-  const piralInstances = [name];
-  const dest = getDestination(entryFiles, resolve(fullBase, target));
-
-  await checkCliCompatibility(root);
-
-  await hooks.beforeBuild?.({ root, publicUrl, externals, entryFiles, piralInstances });
-
-  const bundler = await callPiralDebug(
-    {
-      root,
-      piralInstances,
-      optimizeModules,
-      hmr,
-      externals,
-      publicUrl,
-      entryFiles,
-      logLevel,
-      ignored,
-      ...dest,
-      _,
-    },
-    bundlerName,
-  );
-
-  bundler.ready().then(() => logDone(`Ready!`));
-
-  bundler.on((args) => {
-    hooks.afterBuild?.({ ...args, root, publicUrl, externals, entryFiles, piralInstances, bundler, ...dest });
-  });
 
-  const krasBaseConfig = resolve(fullBase, krasrc);
-  const krasRootConfig = resolve(root, krasrc);
-  const mocks = join(targetDir, 'mocks');
-  const baseMocks = resolve(fullBase, 'mocks');
-  const mocksExist = await checkExistingDirectory(mocks);
-  const sources = [mocksExist ? mocks : undefined].filter(Boolean);
-  const initial = createInitialKrasConfig(baseMocks, sources);
-  const required = {
-    injectors: {
-      piral: {
-        active: true,
-        handle: ['/'],
-        feed,
+  await watcherTask(async (watcherContext) => {
+    progress('Reading configuration ...');
+    const entryFiles = await retrievePiralRoot(fullBase, entry);
+    const targetDir = dirname(entryFiles);
+    const { externals, name, root, ignored } = await retrievePiletsInfo(entryFiles);
+    const piralInstances = [name];
+    const dest = getDestination(entryFiles, resolve(fullBase, target));
+
+    await checkCliCompatibility(root);
+
+    await hooks.beforeBuild?.({ root, publicUrl, externals, entryFiles, piralInstances });
+
+    const bundler = await callPiralDebug(
+      {
+        root,
+        piralInstances,
+        optimizeModules,
+        hmr,
+        externals,
         publicUrl,
-        bundler,
+        entryFiles,
+        logLevel,
+        ignored,
+        ...dest,
+        _,
       },
-      pilet: {
-        active: false,
+      bundlerName,
+    );
+
+    bundler.ready().then(() => logDone(`Ready!`));
+
+    bundler.on((args) => {
+      hooks.afterBuild?.({ ...args, root, publicUrl, externals, entryFiles, piralInstances, bundler, ...dest });
+    });
+
+    const krasBaseConfig = resolve(fullBase, krasrc);
+    const krasRootConfig = resolve(root, krasrc);
+    const mocks = join(targetDir, 'mocks');
+    const baseMocks = resolve(fullBase, 'mocks');
+
+
+    const mocksExist = await checkExistingDirectory(mocks);
+    const sources = [mocksExist ? mocks : undefined].filter(Boolean);
+    const initial = createInitialKrasConfig(baseMocks, sources);
+    const required = {
+      injectors: {
+        piral: {
+          active: true,
+          handle: ['/'],
+          feed,
+          publicUrl,
+          bundler,
+        },
+        pilet: {
+          active: false,
+        },
       },
-    },
-  };
-  const port = await getAvailablePort(originalPort);
-  const krasConfig = readKrasConfig({ port, initial, required }, krasBaseConfig, krasRootConfig);
+    };
+    const krasConfig = readKrasConfig({ port, initial, required }, krasBaseConfig, krasRootConfig);
 
-  log('generalVerbose_0004', `Using kras with configuration: ${JSON.stringify(krasConfig, undefined, 2)}`);
+    log('generalVerbose_0004', `Using kras with configuration: ${JSON.stringify(krasConfig, undefined, 2)}`);
 
-  const krasServer = buildKrasWithCli(krasConfig);
-  krasServer.removeAllListeners('open');
-  krasServer.on('open', notifyServerOnline([bundler], publicUrl, krasConfig.api));
+    const krasServer = buildKrasWithCli(krasConfig);
+    krasServer.removeAllListeners('open');
+    krasServer.on('open', notifyServerOnline([bundler], publicUrl, krasConfig.api));
+
+    await hooks.beforeOnline?.({ krasServer, krasConfig, open, port, publicUrl });
+    await krasServer.start();
+    openBrowser(open, port, publicUrl, !!krasConfig.ssl);
+    await hooks.afterOnline?.({ krasServer, krasConfig, open, port, publicUrl });
+    await new Promise((resolve) => krasServer.on('close', resolve));
+  });
 
-  await hooks.beforeOnline?.({ krasServer, krasConfig, open, port, publicUrl });
-  await krasServer.start();
-  openBrowser(open, port, publicUrl, !!krasConfig.ssl);
-  await hooks.afterOnline?.({ krasServer, krasConfig, open, port, publicUrl });
-  await new Promise((resolve) => krasServer.on('close', resolve));
   await hooks.onEnd?.({});
 }

package/src/apps/upgrade-pilet.ts

@@ -1,7 +1,6 @@
 import { resolve } from 'path';
 import { LogLevels, NpmClientType } from '../types';
 import {
-  readJson,
   installNpmPackage,
   checkExistingDirectory,
   patchPiletPackage,
@@ -24,6 +23,7 @@ import {
   getPiralPath,
   isMonorepoPackageRef,
   getPiletScaffoldData,
+  retrievePiletData,
 } from '../common';
 
 export interface UpgradePiletOptions {
@@ -99,11 +99,11 @@ export async function upgradePilet(baseDir = process.cwd(), options: UpgradePile
   }
 
   const npmClient = await determineNpmClient(root, defaultNpmClient);
-  const pckg = await readJson(root, 'package.json');
-  const { devDependencies = {}, dependencies = {}, piral, source } = pckg;
+  const { apps, piletPackage } = await retrievePiletData(root);
+  const { devDependencies = {}, dependencies = {}, source } = piletPackage;
 
-  if (piral && typeof piral === 'object') {
-    const sourceName = piral.name;
+  for (const { appPackage } of apps) {
+    const sourceName = appPackage.name;
     const language = /\.jsx?$/.test(source) ? 'js' : 'ts';
 
     if (!sourceName || typeof sourceName !== 'string') {
@@ -170,9 +170,7 @@ export async function upgradePilet(baseDir = process.cwd(), options: UpgradePile
       log('generalDebug_0003', `Run: ${postUpgrade}`);
       await runScript(postUpgrade, root);
     }
-
-    logDone('Pilet upgraded successfully!');
-  } else {
-    fail('invalidPiletPackage_0041');
   }
+
+  logDone('Pilet upgraded successfully!');
 }

package/src/common/declaration.ts

@@ -124,6 +124,7 @@ export async function createPiletDeclaration(
     types: [...types, ...files],
     plugins: [createExcludePlugin([name])],
     apis: [],
+    noModuleDeclaration: true,
     imports: allowedImports,
     logLevel,
     logger: createLogger(),
@@ -149,6 +150,7 @@ export async function createPiralDeclaration(
     files,
     types: findDeclaredTypings(root),
     apis: findPiralBaseApi(root),
+    noModuleDeclaration: true,
     imports: externals,
     logLevel,
     logger: createLogger(),

package/src/common/index.ts

@@ -30,3 +30,5 @@ export * from './scripts';
 export * from './spec';
 export * from './template';
 export * from './url';
+export * from './version';
+export * from './watcher';

package/src/common/package.ts

@@ -574,7 +574,7 @@ export async function patchPiletPackage(
   log('generalDebug_0003', `Succesfully patched the pilet.json.`);
 }
 
-export async function getPiletPackage(
+async function getPiletPackage(
   root: string,
   name: string,
   version: string,
@@ -582,11 +582,13 @@ export async function getPiletPackage(
   fromEmulator: boolean,
   newInfo?: { language: SourceLanguage; bundler: string },
 ) {
+  const { piralCLI = { version: cliVersion } } = piralInfo;
   const { externals, packageOverrides, ...info } = getPiletsInfo(piralInfo);
   const piralDependencies = {
     ...piralInfo.devDependencies,
     ...piralInfo.dependencies,
   };
+  const toolVersion = piralCLI.version;
   const typeDependencies = newInfo ? getDevDependencies(newInfo.language) : {};
   const scripts = newInfo
     ? {
@@ -617,13 +619,11 @@ export async function getPiletPackage(
       return deps;
     }, {}),
     [name]: `${version || piralInfo.version}`,
+    ['piral-cli']: toolVersion,
   };
 
   if (newInfo) {
-    const bundler = newInfo.bundler;
-    const version = `^${cliVersion}`;
-    devDependencies['piral-cli'] = version;
-    await appendBundler(devDependencies, bundler, version);
+    await appendBundler(devDependencies, newInfo.bundler, toolVersion);
   }
 
   return deepMerge(packageOverrides, {

package/src/common/watcher.ts

@@ -0,0 +1,24 @@
+export interface WatcherContext {
+  onClean(dispose: () => void): void;
+  watch(file: string): void;
+}
+
+export function watcherTask(cb: (watcherContext: WatcherContext) => Promise<void>) {
+  return new Promise<void>((resolve, reject) => {
+    const disposers: Array<() => void> = [];
+    const context: WatcherContext = {
+      onClean(dispose) {
+        disposers.push(dispose);
+      },
+      watch(file) {},
+    };
+    cb(context).then(
+      () => {
+        resolve();
+      },
+      (err) => {
+        reject(err);
+      },
+    );
+  });
+}