piral-cli 0.14.24-beta.4163 → 0.14.24-beta.4191

package/src/common/npm.test.ts

@@ -2,11 +2,11 @@ import { resolve } from 'path';
 import { clients } from './clients';
 import {
   dissectPackageName,
-  installPackage,
+  installNpmPackage,
   isMonorepoPackageRef,
-  installDependencies,
-  createPackage,
-  findTarball,
+  installNpmDependencies,
+  createNpmPackage,
+  findNpmTarball,
   findSpecificVersion,
   findLatestVersion,
   isLocalPackage,
@@ -40,8 +40,8 @@ jest.mock('../external', () => ({
 let specialCase = false;
 let shouldFind = true;
 let wrongCase = false;
-const jsonValueString = JSON.stringify({ dependencies: { npm: { extraneous: true } } });
-const jsonValueStringWrong = JSON.stringify({ dependencies: {} });
+const jsonValueString = JSON.stringify([{ name: 'npm' }]);
+const jsonValueStringWrong = JSON.stringify([]);
 
 jest.mock('./scripts', () => ({
   runCommand: (exe: string, args: Array<string>, cwd: string, output?: NodeJS.WritableStream) => {
@@ -165,37 +165,39 @@ describe('npm Module', () => {
 
   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));
+    await installNpmPackage('npm', 'foo', 'latest').then((result) => expect(result).toEqual(jsonValueString));
     wrongCase = true;
-    await installPackage('npm', 'foo', 'latest').then((result) => expect(result).not.toEqual(jsonValueString));
+    await installNpmPackage('npm', 'foo', 'latest').then((result) => expect(result).not.toEqual(jsonValueString));
   });
 
   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));
+    await installNpmPackage('npm', 'foo').then((result) => expect(result).toEqual(jsonValueString));
     wrongCase = true;
-    await installPackage('npm', 'foo').then((result) => expect(result).not.toEqual(jsonValueString));
+    await installNpmPackage('npm', 'foo').then((result) => expect(result).not.toEqual(jsonValueString));
   });
 
   it('installs a package using the Yarn command line tool without a version', async () => {
     wrongCase = false;
-    await installPackage('yarn', 'foo').then((result) => expect(result).toEqual(jsonValueString));
+    await installNpmPackage('yarn', 'foo').then((result) => expect(result).toEqual(jsonValueString));
     wrongCase = true;
-    await installPackage('yarn', 'foo').then((result) => expect(result).not.toEqual(jsonValueString));
+    await installNpmPackage('yarn', 'foo').then((result) => expect(result).not.toEqual(jsonValueString));
   });
 
   it('installs a package using the Pnpm command line tool without a version', async () => {
     wrongCase = false;
-    await installPackage('pnpm', 'foo').then((result) => expect(result).toEqual(jsonValueString));
+    await installNpmPackage('pnpm', 'foo').then((result) => expect(result).toEqual(jsonValueString));
     wrongCase = true;
-    await installPackage('pnpm', 'foo').then((result) => expect(result).not.toEqual(jsonValueString));
+    await installNpmPackage('pnpm', 'foo').then((result) => expect(result).not.toEqual(jsonValueString));
   });
 
   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));
+    await installNpmPackage('npm', 'foo', '1.3', '.', '--a=b').then((result) =>
+      expect(result).toEqual(jsonValueString),
+    );
     wrongCase = true;
-    await installPackage('npm', 'foo', '1.3', '.', '--a=b').then((result) =>
+    await installNpmPackage('npm', 'foo', '1.3', '.', '--a=b').then((result) =>
       expect(result).not.toEqual(jsonValueString),
     );
   });
@@ -242,37 +244,37 @@ describe('npm Module', () => {
 
   it('install dependencies with npm client', async () => {
     wrongCase = false;
-    await installDependencies('npm').then((result) => expect(result).toEqual(jsonValueString));
+    await installNpmDependencies('npm').then((result) => expect(result).toEqual(jsonValueString));
     wrongCase = true;
-    await installDependencies('npm').then((result) => expect(result).not.toEqual(jsonValueString));
+    await installNpmDependencies('npm').then((result) => expect(result).not.toEqual(jsonValueString));
   });
 
   it('install dependencies with pnpm client', async () => {
     wrongCase = false;
-    await installDependencies('pnpm').then((result) => expect(result).toEqual(jsonValueString));
+    await installNpmDependencies('pnpm').then((result) => expect(result).toEqual(jsonValueString));
     wrongCase = true;
-    await installDependencies('pnpm').then((result) => expect(result).not.toEqual(jsonValueString));
+    await installNpmDependencies('pnpm').then((result) => expect(result).not.toEqual(jsonValueString));
   });
 
   it('install dependencies with yarn client', async () => {
     wrongCase = false;
-    await installDependencies('yarn').then((result) => expect(result).toEqual(jsonValueString));
+    await installNpmDependencies('yarn').then((result) => expect(result).toEqual(jsonValueString));
     wrongCase = true;
-    await installDependencies('yarn').then((result) => expect(result).not.toEqual(jsonValueString));
+    await installNpmDependencies('yarn').then((result) => expect(result).not.toEqual(jsonValueString));
   });
 
   it('create npm package', async () => {
     wrongCase = false;
-    await createPackage().then((result) => expect(result).toEqual(jsonValueString));
+    await createNpmPackage().then((result) => expect(result).toEqual(jsonValueString));
     wrongCase = true;
-    await createPackage().then((result) => expect(result).not.toEqual(jsonValueString));
+    await createNpmPackage().then((result) => expect(result).not.toEqual(jsonValueString));
   });
 
   it('find npm tarball', async () => {
     wrongCase = false;
-    await findTarball('foo').then((result) => expect(result).toEqual(jsonValueString));
+    await findNpmTarball('foo').then((result) => expect(result).toEqual(jsonValueString));
     wrongCase = true;
-    await findTarball('foo').then((result) => expect(result).not.toEqual(jsonValueString));
+    await findNpmTarball('foo').then((result) => expect(result).not.toEqual(jsonValueString));
   });
 
   it('find latest version', async () => {
@@ -438,7 +440,7 @@ describe('npm Module', () => {
   });
 
   it('makeExternals without externals returns coreExternals', () => {
-    const externals = makeExternals({ piral: '*' });
+    const externals = makeExternals(process.cwd(), { piral: '*' });
     expect(externals).toEqual([
       'react',
       'react-dom',
@@ -453,7 +455,7 @@ describe('npm Module', () => {
   });
 
   it('makeExternals with no externals returns coreExternals', () => {
-    const externals = makeExternals({ piral: '*' }, []);
+    const externals = makeExternals(process.cwd(), { piral: '*' }, []);
     expect(externals).toEqual([
       'react',
       'react-dom',
@@ -468,12 +470,12 @@ describe('npm Module', () => {
   });
 
   it('makeExternals with exclude coreExternals returns empty set', () => {
-    const externals = makeExternals({ piral: '*' }, ['!*']);
+    const externals = makeExternals(process.cwd(), { piral: '*' }, ['!*']);
     expect(externals).toEqual([]);
   });
 
   it('makeExternals with externals concats coreExternals', () => {
-    const externals = makeExternals({ piral: '*' }, ['foo', 'bar']);
+    const externals = makeExternals(process.cwd(), { piral: '*' }, ['foo', 'bar']);
     expect(externals).toEqual([
       'foo',
       'bar',
@@ -490,7 +492,7 @@ describe('npm Module', () => {
   });
 
   it('makeExternals with external duplicate only reflects coreExternals', () => {
-    const externals = makeExternals({ piral: '*' }, ['react', 'foo']);
+    const externals = makeExternals(process.cwd(), { piral: '*' }, ['react', 'foo']);
     expect(externals).toEqual([
       'react',
       'foo',
@@ -506,7 +508,7 @@ describe('npm Module', () => {
   });
 
   it('makeExternals with explicit include and exclude', () => {
-    const externals = makeExternals({ piral: '*' }, ['react', 'react-calendar', '!history']);
+    const externals = makeExternals(process.cwd(), { piral: '*' }, ['react', 'react-calendar', '!history']);
     expect(externals).toEqual([
       'react',
       'react-calendar',
@@ -521,7 +523,7 @@ describe('npm Module', () => {
   });
 
   it('makeExternals with all exclude and explicit include', () => {
-    const externals = makeExternals({ piral: '*' }, ['react', 'react-router-dom', '!*']);
+    const externals = makeExternals(process.cwd(), { piral: '*' }, ['react', 'react-router-dom', '!*']);
     expect(externals).toEqual(['react', 'react-router-dom']);
   });
 });

package/src/common/npm.ts

@@ -5,7 +5,7 @@ import { clients, detectClients, isWrapperClient } from './clients';
 import { config } from './config';
 import { legacyCoreExternals, frameworkLibs } from './constants';
 import { inspectPackage } from './inspect';
-import { readJson, checkExists, findFile } from './io';
+import { readJson, checkExists } from './io';
 import { clientTypeKeys } from '../helpers';
 import { PackageType, NpmClientType } from '../types';
 
@@ -24,30 +24,37 @@ function resolveAbsPath(basePath: string, fullName: string) {
   return resolve(basePath, relPath);
 }
 
-async function detectMonorepoRoot(root: string): Promise<string> {
+async function detectMonorepoRoot(root: string): Promise<[] | [string, NpmClientType]> {
   let previous = root;
 
   do {
-    const isMonorepo =
-      (await checkExists(resolve(root, 'lerna.json'))) ||
-      (await checkExists(resolve(root, 'rush.json'))) ||
-      (await checkExists(resolve(root, 'pnpm-workspace.yaml')));
+    if (await checkExists(resolve(root, 'lerna.json'))) {
+      return [root, 'lerna'];
+    }
+
+    if (await checkExists(resolve(root, 'rush.json'))) {
+      return [root, 'rush'];
+    }
 
-    if (isMonorepo) {
-      return root;
+    if (await checkExists(resolve(root, 'pnpm-workspace.yaml'))) {
+      return [root, 'pnpm'];
     }
 
     const packageJson = await readJson(root, 'package.json');
 
     if (Array.isArray(packageJson?.workspaces)) {
-      return root;
+      if (await checkExists(resolve(root, 'yarn.lock'))) {
+        return [root, 'yarn'];
+      }
+
+      return [root, 'npm'];
     }
 
     previous = root;
     root = dirname(root);
   } while (root !== previous);
 
-  return undefined;
+  return [];
 }
 
 /**
@@ -103,23 +110,22 @@ export async function determineNpmClient(root: string, selected?: NpmClientType)
 }
 
 export async function isMonorepoPackageRef(refName: string, root: string): Promise<boolean> {
-  const newRoot = await detectMonorepoRoot(root);
+  const [monorepoRoot, client] = await detectMonorepoRoot(root);
 
-  if (newRoot) {
-    const { listPackage } = clients.npm;
-    const details = await listPackage(refName, newRoot);
-    return details?.dependencies?.[refName]?.extraneous ?? false;
+  if (monorepoRoot) {
+    const c = clients[client];
+    return await c.isProject(monorepoRoot, refName);
   }
 
   return false;
 }
 
-export function installDependencies(client: NpmClientType, target = '.'): Promise<string> {
+export function installNpmDependencies(client: NpmClientType, target = '.'): Promise<string> {
   const { installDependencies } = clients[client];
   return installDependencies(target);
 }
 
-export async function installPackage(
+export async function installNpmPackage(
   client: NpmClientType,
   packageRef: string,
   target = '.',
@@ -137,17 +143,22 @@ export async function installPackage(
   }
 }
 
-export function publishPackage(target = '.', file = '*.tgz', flags: Array<string> = []): Promise<string> {
+export function initNpmProject(client: NpmClientType, projectName: string, target: string) {
+  const { initProject } = clients[client];
+  return initProject(projectName, target);
+}
+
+export function publishNpmPackage(target = '.', file = '*.tgz', flags: Array<string> = []): Promise<string> {
   const { publishPackage } = clients.npm;
   return publishPackage(target, file, ...flags);
 }
 
-export function createPackage(target = '.'): Promise<string> {
+export function createNpmPackage(target = '.'): Promise<string> {
   const { createPackage } = clients.npm;
   return createPackage(target);
 }
 
-export function findTarball(packageRef: string): Promise<string> {
+export function findNpmTarball(packageRef: string): Promise<string> {
   const { findTarball } = clients.npm;
   return findTarball(packageRef);
 }
@@ -321,7 +332,8 @@ export function isLinkedPackage(name: string, type: PackageType, hadVersion: boo
 
 export function combinePackageRef(name: string, version: string, type: PackageType) {
   if (type === 'registry') {
-    return `${name}@${version || 'latest'}`;
+    const tag = version || 'latest';
+    return `${name}@${tag}`;
   }
 
   return name;
@@ -375,19 +387,22 @@ export function getPackageVersion(
   }
 }
 
-function getExternalsFrom(packageName: string): Array<string> | undefined {
+function getExternalsFrom(root: string, packageName: string): Array<string> | undefined {
   try {
-    return require(`${packageName}/package.json`).sharedDependencies;
+    const target = require.resolve(`${packageName}/package.json`, {
+      paths: [root],
+    });
+    return require(target).sharedDependencies;
   } catch (err) {
     log('generalError_0002', `Could not get externals from "${packageName}": "${err}`);
     return undefined;
   }
 }
 
-function getCoreExternals(dependencies: Record<string, string>): Array<string> {
+function getCoreExternals(root: string, dependencies: Record<string, string>): Array<string> {
   for (const frameworkLib of frameworkLibs) {
     if (dependencies[frameworkLib]) {
-      const deps = getExternalsFrom(frameworkLib);
+      const deps = getExternalsFrom(root, frameworkLib);
 
       if (deps) {
         return deps;
@@ -400,24 +415,23 @@ function getCoreExternals(dependencies: Record<string, string>): Array<string> {
 }
 
 export function makePiletExternals(
+  root: string,
   dependencies: Record<string, string>,
   externals: Array<string>,
   fromEmulator: boolean,
   piralInfo: any,
-) {
+): Array<string> {
   if (fromEmulator) {
-    const { sharedDependencies = makeExternals(dependencies, externals, true) } = piralInfo;
+    const { sharedDependencies = mergeExternals(externals, legacyCoreExternals) } = piralInfo;
     return sharedDependencies;
   } else {
-    return makeExternals(dependencies, externals);
+    return makeExternals(root, dependencies, externals);
   }
 }
 
-export function makeExternals(dependencies: Record<string, string>, externals?: Array<string>, legacy = false) {
-  const coreExternals = legacy ? legacyCoreExternals : getCoreExternals(dependencies);
-
-  if (externals && Array.isArray(externals)) {
-    const [include, exclude] = externals.reduce<[Array<string>, Array<string>]>(
+export function mergeExternals(customExternals?: Array<string>, coreExternals: Array<string> = []) {
+  if (customExternals && Array.isArray(customExternals)) {
+    const [include, exclude] = customExternals.reduce<[Array<string>, Array<string>]>(
       (prev, curr) => {
         if (typeof curr === 'string') {
           if (curr.startsWith('!')) {
@@ -437,3 +451,8 @@ export function makeExternals(dependencies: Record<string, string>, externals?:
 
   return coreExternals;
 }
+
+export function makeExternals(root: string, dependencies: Record<string, string>, externals?: Array<string>) {
+  const coreExternals = getCoreExternals(root, dependencies);
+  return mergeExternals(externals, coreExternals);
+}

package/src/common/pack.test.ts

@@ -13,7 +13,7 @@ jest.mock('./io', () => ({
 }));
 
 jest.mock('./npm', () => ({
-  createPackage: (target?: string) => {
+  createNpmPackage: (target?: string) => {
     return Promise.resolve(target);
   },
 }));

package/src/common/pack.ts

@@ -1,7 +1,7 @@
 import { resolve, join } from 'path';
 import { log, progress, fail } from './log';
 import { readJson, move } from './io';
-import { createPackage } from './npm';
+import { createNpmPackage } from './npm';
 import { ForceOverwrite } from './enums';
 
 async function getFile(root: string, name: string, dest: string) {
@@ -38,7 +38,7 @@ export async function createPiletPackage(baseDir: string, source: string, target
 
   progress(`Packing pilet in ${dest} ...`);
   log('generalDebug_0003', 'Creating package ...');
-  await createPackage(root);
+  await createNpmPackage(root);
   log('generalDebug_0003', 'Successfully created package.');
   const name = `${pckg.name}-${pckg.version}.tgz`.replace(/@/g, '').replace(/\//g, '-');
   log('generalDebug_0003', `Assumed package name "${name}".`);

package/src/common/package.ts

@@ -12,7 +12,7 @@ import { isGitPackage, isLocalPackage, makeGitUrl, makeFilePath, makePiletExtern
 import { filesTar, filesOnceTar, declarationEntryExtensions, bundlerNames } from './constants';
 import { getHash, checkIsDirectory, matchFiles } from './io';
 import { readJson, copy, updateExistingJson, findFile, checkExists } from './io';
-import { Framework, FileInfo, PiletsInfo, TemplateFileLocation, SharedDependency } from '../types';
+import { Framework, FileInfo, PiletsInfo, TemplateFileLocation, SharedDependency, PackageData } from '../types';
 
 function appendBundler(devDependencies: Record<string, string>, bundler: string, version: string) {
   if (bundler && bundler !== 'none') {
@@ -159,7 +159,7 @@ function findPackage(pck: string | Array<string>, baseDir: string) {
   return undefined;
 }
 
-export function readPiralPackage(root: string, name: string) {
+export function readPiralPackage(root: string, name: string): Promise<PackageData> {
   log('generalDebug_0003', `Reading the piral package in "${root}" ...`);
   const path = getPiralPath(root, name);
   return readJson(path, 'package.json');
@@ -319,10 +319,19 @@ function isTemplateFileLocation(item: string | TemplateFileLocation): item is Te
   return typeof item === 'object';
 }
 
+function tryFindPackageVersion(packageName: string): string {
+  try {
+    const { version } = require(`${packageName}/package.json`);
+    return version;
+  } catch {
+    return undefined;
+  }
+}
+
 export async function copyPiralFiles(
   root: string,
   name: string,
-  piralInfo: any,
+  piralInfo: PackageData,
   forceOverwrite: ForceOverwrite,
   variables: Record<string, string>,
   originalFiles?: Array<FileInfo>,
@@ -342,7 +351,7 @@ export async function copyPiralFiles(
   await copyFiles(files, forceOverwrite, originalFiles, variables);
 }
 
-export function getPiletsInfo(piralInfo: any): PiletsInfo {
+export function getPiletsInfo(piralInfo: Partial<PackageData>): PiletsInfo {
   const {
     files = [],
     externals = [],
@@ -457,13 +466,14 @@ export async function retrievePiletsInfo(entryFile: string) {
     fail('packageJsonMissing_0074');
   }
 
+  const root = dirname(packageJson);
   const packageInfo = require(packageJson);
   const allDeps = {
     ...packageInfo.devDependencies,
     ...packageInfo.dependencies,
   };
   const info = getPiletsInfo(packageInfo);
-  const externals = makeExternals(allDeps, info.externals);
+  const externals = makeExternals(root, allDeps, info.externals);
 
   return {
     ...info,
@@ -477,7 +487,7 @@ export async function retrievePiletsInfo(entryFile: string) {
     },
     scripts: packageInfo.scripts,
     ignored: checkArrayOrUndefined(packageInfo, 'preservedDependencies'),
-    root: dirname(packageJson),
+    root,
   };
 }
 
@@ -491,7 +501,7 @@ export async function patchPiletPackage(
   root: string,
   name: string,
   version: string,
-  piralInfo: any,
+  piralInfo: PackageData,
   fromEmulator: boolean,
   newInfo?: { language: SourceLanguage; bundler: string },
 ) {
@@ -515,7 +525,7 @@ export async function patchPiletPackage(
       }
     : info.scripts;
   const peerModules = [];
-  const allExternals = makePiletExternals(piralDependencies, externals, fromEmulator, piralInfo);
+  const allExternals = makePiletExternals(root, piralDependencies, externals, fromEmulator, piralInfo);
   const peerDependencies = {
     ...allExternals.reduce((deps, name) => {
       const valid = isValidDependency(name);
@@ -539,7 +549,7 @@ export async function patchPiletPackage(
       return deps;
     }, {}),
     ...allExternals.filter(isValidDependency).reduce((deps, name) => {
-      const version = piralDependencies[name];
+      const version = piralDependencies[name] || tryFindPackageVersion(name);
 
       if (version || newInfo) {
         // set only if we have an explicit version or we are in the scaffolding case
@@ -576,7 +586,7 @@ export async function patchPiletPackage(
 /**
  * Returns true if its an emulator package, otherwise it has to be a "raw" app shell.
  */
-export function checkAppShellPackage(appPackage: any) {
+export function checkAppShellPackage(appPackage: PackageData) {
   const { piralCLI = { generated: false, version: cliVersion } } = appPackage;
 
   if (piralCLI.generated) {

package/src/common/scaffold.ts

@@ -1,5 +1,5 @@
 import { join, dirname, resolve, basename, isAbsolute } from 'path';
-import { installPackage } from './npm';
+import { installNpmPackage } from './npm';
 import { ForceOverwrite, SourceLanguage } from './enums';
 import { createDirectory, createFileIfNotExists, updateExistingJson } from './io';
 import { log, fail } from './log';
@@ -36,7 +36,7 @@ async function getTemplateFiles(
   if (templatePackageName.startsWith('.')) {
     templatePackageName = resolve(process.cwd(), templatePackageName);
   } else {
-    await installPackage('npm', templatePackageName, __dirname, '--registry', registry);
+    await installNpmPackage('npm', templatePackageName, __dirname, '--registry', registry);
   }
 
   const templateRunner = getTemplatePackage(templatePackageName);

package/src/external/index.ts

@@ -1,6 +1,7 @@
 import logger = require('@parcel/logger');
 import stripAnsi = require('strip-ansi');
 import inquirer = require('inquirer');
+import jju = require('jju');
 import glob = require('glob');
 import tar = require('tar');
 import FormData = require('form-data');
@@ -10,4 +11,4 @@ import mime = require('mime');
 import getPort = require('get-port');
 import open = require('open');
 
-export { logger, inquirer, glob, tar, FormData, rc, axios, mime, stripAnsi, getPort, open };
+export { logger, inquirer, glob, tar, FormData, rc, axios, mime, stripAnsi, getPort, open, jju };

package/src/injectors/pilet.ts

@@ -6,7 +6,7 @@ import { KrasInjector, KrasResponse, KrasRequest, KrasInjectorConfig, KrasConfig
 import { log } from '../common/log';
 import { getPiletSpecMeta } from '../common/spec';
 import { config } from '../common/config';
-import { axios, mime } from '../external';
+import { axios, mime, jju } from '../external';
 import { Bundler } from '../types';
 
 const { host } = config;
@@ -35,8 +35,8 @@ function fillPiletMeta(pilet: Pilet, basePath: string, metaFile: string) {
   const { root, bundler } = pilet;
   const metaPath = join(root, metaFile);
   const packagePath = join(root, 'package.json');
-  const def = JSON.parse(readFileSync(packagePath, 'utf8'));
-  const metaOverride = existsSync(metaPath) ? JSON.parse(readFileSync(metaPath, 'utf8')) : undefined;
+  const def = jju.parse(readFileSync(packagePath, 'utf8'));
+  const metaOverride = existsSync(metaPath) ? jju.parse(readFileSync(metaPath, 'utf8')) : undefined;
   const file = bundler.bundle.name.replace(/^[\/\\]/, '');
   const target = join(bundler.bundle.dir, file);
   const url = new URL(file, basePath);

package/src/plugin.ts

@@ -6,11 +6,11 @@ import { inject } from './inject';
 function getContainerDir() {
   const currentDir = __dirname.split(sep).join(posix.sep);
 
-  if (currentDir.includes(`/.pnpm/${cliName}@${cliVersion}/node_modules/${cliName}/`)) {
-    return resolve(__dirname, '..', '..', '..', '..', '..');
+  if (!currentDir.includes(`/.pnpm/${cliName}@${cliVersion}/node_modules/${cliName}/`)) {
+    return resolve(__dirname, '..', '..');
   }
 
-  return resolve(__dirname, '..', '..');
+  return undefined;
 }
 
 async function getLocalPackageDir() {
@@ -25,7 +25,7 @@ async function getLocalPackageDir() {
   // Right now we always take the first one, but in the future this may be different
   // once we come up with more / better criteria to identify if its a good/valid
   // plugin root directory
-  for (const dir of proposedDirs) {
+  for (const dir of proposedDirs.filter(Boolean)) {
     log('generalDebug_0003', `Checking for potential plugin directory "${dir}" ...`);
 
     if (await isDirectory(dir)) {

package/src/types/internal.ts

@@ -1,4 +1,4 @@
-import { LogLevels } from './common';
+import type { LogLevels, PiletsInfo } from './common';
 
 export interface PackageData {
   name: string;
@@ -13,6 +13,11 @@ export interface PackageData {
         email?: string;
       };
   custom?: any;
+  pilets?: PiletsInfo;
+  piralCLI?: { generated: boolean; version: string };
+  dependencies: Record<string, string>;
+  peerDependencies: Record<string, string>;
+  devDependencies: Record<string, string>;
 }
 
 export interface PackageFiles {