piral-cli 0.14.1 → 0.14.3-beta.3296

package/src/apps/publish-pilet.ts

@@ -1,5 +1,5 @@
-import { relative, join, dirname, basename, resolve } from 'path';
-import { buildPilet } from './build-pilet';
+import { relative, dirname, basename, resolve } from 'path';
+import { callPiletBuild } from '../bundler';
 import { LogLevels, PiletSchemaVersion, PiletPublishSource } from '../types';
 import {
   postFile,
@@ -15,6 +15,10 @@ import {
   checkExists,
   findTarball,
   downloadFile,
+  matchAnyPilet,
+  retrievePiletData,
+  removeDirectory,
+  logInfo,
 } from '../common';
 
 export interface PublishPiletOptions {
@@ -23,7 +27,7 @@ export interface PublishPiletOptions {
    * used with `--fresh`, otherwise expects source to be a path leading
    * to a `*.tgz` file.
    */
-  source?: string;
+  source?: string | Array<string>;
 
   /**
    * Sets the URL of the feed service to deploy to.
@@ -67,6 +71,16 @@ export interface PublishPiletOptions {
    * Places additional fields that should be posted to the feed service.
    */
   fields?: Record<string, string>;
+
+  /**
+   * Sets the bundler to use for building, if any specific.
+   */
+  bundlerName?: string;
+
+  /**
+   * Additional arguments for a specific bundler.
+   */
+  _?: Record<string, any>;
 }
 
 export const publishPiletDefaults: PublishPiletOptions = {
@@ -83,41 +97,94 @@ export const publishPiletDefaults: PublishPiletOptions = {
 
 async function getFiles(
   baseDir: string,
-  source: string,
+  sources: Array<string>,
   from: PiletPublishSource,
   fresh: boolean,
   schemaVersion: PiletSchemaVersion,
+  logLevel: LogLevels,
+  bundlerName: string,
+  _?: Record<string, any>,
   ca?: Buffer,
 ): Promise<Array<string>> {
   if (fresh) {
     log('generalDebug_0003', 'Detected "--fresh". Trying to resolve the package.json.');
-    const details = require(join(baseDir, 'package.json'));
-    progress('Triggering pilet build ...');
-    await buildPilet(baseDir, {
-      target: details.main,
-      fresh,
-      schemaVersion,
-    });
-    log('generalDebug_0003', 'Successfully built.');
-    progress('Triggering pilet pack ...');
-    const file = await createPiletPackage(baseDir, '.', '.');
-    log('generalDebug_0003', 'Successfully packed.');
-    return [file];
+    const allEntries = await matchAnyPilet(baseDir, sources);
+
+    if (allEntries.length === 0) {
+      fail('entryFileMissing_0077');
+    }
+
+    return await Promise.all(
+      allEntries.map(async (entryModule) => {
+        const targetDir = dirname(entryModule);
+        const { root, piletPackage, importmap, peerDependencies, peerModules, appPackage } = await retrievePiletData(
+          targetDir,
+        );
+        const dest = resolve(root, piletPackage.main);
+        const outDir = dirname(dest);
+        const outFile = basename(dest);
+        const externals = [...Object.keys(peerDependencies), ...peerModules];
+        progress('Triggering pilet build ...');
+
+        if (fresh) {
+          progress('Removing output directory ...');
+          await removeDirectory(outDir);
+        }
+
+        logInfo('Bundle pilet ...');
+
+        await callPiletBuild(
+          {
+            root,
+            piral: appPackage.name,
+            optimizeModules: false,
+            sourceMaps: true,
+            contentHash: true,
+            minify: true,
+            externals,
+            targetDir,
+            importmap,
+            outFile,
+            outDir,
+            entryModule: `./${relative(root, entryModule)}`,
+            logLevel,
+            version: schemaVersion,
+            ignored: [],
+            _,
+          },
+          bundlerName,
+        );
+
+        log('generalDebug_0003', `Pilet "${piletPackage.name}" built successfully!`);
+        progress('Triggering pilet pack ...');
+
+        const file = await createPiletPackage(root, '.', '.');
+        log('generalDebug_0003', `Pilet "${piletPackage.name}" packed successfully!`);
+
+        return file;
+      }),
+    );
   } else {
     log('generalDebug_0003', `Did not find fresh flag. Trying to match from "${from}".`);
 
     switch (from) {
-      case 'local':
-        log('generalDebug_0003', `Matching files using "${source}".`);
-        return await matchFiles(baseDir, source);
-      case 'remote':
-        log('generalDebug_0003', `Download file from "${source}".`);
-        return await downloadFile(source, ca);
-      case 'npm':
-        log('generalDebug_0003', `View npm package "${source}".`);
-        const url = await findTarball(source);
-        log('generalDebug_0003', `Download file from "${url}".`);
-        return await downloadFile(url, ca);
+      case 'local': {
+        log('generalDebug_0003', `Matching files using "${sources.join('", "')}".`);
+        const allFiles = await Promise.all(sources.map((s) => matchFiles(baseDir, s)));
+        return allFiles.reduce((result, files) => [...result, ...files], []);
+      }
+      case 'remote': {
+        log('generalDebug_0003', `Download file from "${sources.join('", "')}".`);
+        const allFiles = await Promise.all(sources.map((s) => downloadFile(s, ca)));
+        return allFiles.reduce((result, files) => [...result, ...files], []);
+      }
+      case 'npm': {
+        log('generalDebug_0003', `View npm package "${sources.join('", "')}".`);
+        const allUrls = await Promise.all(sources.map((s) => findTarball(s)));
+        log('generalDebug_0003', `Download file from "${allUrls.join('", "')}".`);
+        const allFiles = await Promise.all(allUrls.map((url) => downloadFile(url, ca)));
+        return allFiles.reduce((result, files) => [...result, ...files], []);
+      }
     }
   }
 }
@@ -133,6 +200,8 @@ export async function publishPilet(baseDir = process.cwd(), options: PublishPile
     schemaVersion = publishPiletDefaults.schemaVersion,
     cert = config.cert ?? publishPiletDefaults.cert,
     fields = publishPiletDefaults.fields,
+    _ = {},
+    bundlerName,
   } = options;
   const fullBase = resolve(process.cwd(), baseDir);
   setLogLevel(logLevel);
@@ -153,12 +222,13 @@ export async function publishPilet(baseDir = process.cwd(), options: PublishPile
   }
 
   log('generalDebug_0003', 'Getting the tgz files ...');
-  const files = await getFiles(fullBase, source, from, fresh, schemaVersion, ca);
+  const sources = Array.isArray(source) ? source : [source];
+  const files = await getFiles(fullBase, sources, from, fresh, schemaVersion, logLevel, bundlerName, _, ca);
   const successfulUploads: Array<string> = [];
   log('generalDebug_0003', 'Received available tgz files.');
 
   if (files.length === 0) {
-    fail('missingPiletTarball_0061', source);
+    fail('missingPiletTarball_0061', sources);
   }
 
   log('generalInfo_0000', `Using feed service "${url}".`);

package/src/build/bundler-calls.ts

@@ -54,7 +54,7 @@ function createBundler(cwd: string, ps: ChildProcess, args: any) {
 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 ps = fork(getPath(name), [], { cwd, stdio: 'pipe' });
     const bundler = createBundler(cwd, ps, args);
     const setup = {
       type: 'init',
@@ -67,6 +67,10 @@ export function callDynamic<T extends BaseBundleParameters>(name: string, path:
       });
     };
 
+    ps.stderr.pipe(process.stderr);
+    ps.stdout.pipe(process.stdout);
+    ps.stdin.pipe(process.stdin);
+
     ps.on('message', (msg: any) => {
       switch (msg.type) {
         case 'pending':
@@ -92,7 +96,7 @@ export function callDynamic<T extends BaseBundleParameters>(name: string, path:
 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 ps = fork(getPath(name), [], { cwd, stdio: 'pipe' });
     const bundler = createBundler(cwd, ps, args);
     const setup = {
       type: 'init',
@@ -105,6 +109,10 @@ export function callStatic<T extends BaseBundleParameters>(name: string, path: s
       });
     };
 
+    ps.stderr.pipe(process.stderr);
+    ps.stdout.pipe(process.stdout);
+    ps.stdin.pipe(process.stdin);
+
     ps.on('message', (msg: any) => {
       switch (msg.type) {
         case 'done':

package/src/commands.ts

@@ -1,3 +1,4 @@
+import { piletBuildTypeKeys } from '.';
 import * as apps from './apps';
 import {
   availableBundlers,
@@ -13,7 +14,7 @@ import {
   schemaKeys,
   fromKeys,
   bundlerKeys,
-  buildTypeKeys,
+  piralBuildTypeKeys,
 } from './helpers';
 import {
   ToolCommand,
@@ -23,6 +24,7 @@ import {
   PiralBuildType,
   PiletPublishSource,
   PiletSchemaVersion,
+  PiletBuildType,
 } from './types';
 
 function specializeCommand(commands: Array<ToolCommand<any>>, command: ToolCommand<any>, suffix: string) {
@@ -143,7 +145,7 @@ const allCommands: Array<ToolCommand<any>> = [
         .boolean('optimize-modules')
         .describe('optimize-modules', 'Also includes the node modules for target transpilation.')
         .default('optimize-modules', apps.buildPiralDefaults.optimizeModules)
-        .choices('type', buildTypeKeys)
+        .choices('type', piralBuildTypeKeys)
         .describe('type', 'Selects the target type of the build. "all" builds all target types.')
         .default('type', apps.buildPiralDefaults.type)
         .choices('bundler', availableBundlers)
@@ -186,7 +188,7 @@ const allCommands: Array<ToolCommand<any>> = [
         .number('log-level')
         .describe('log-level', 'Sets the log level to use (1-5).')
         .default('log-level', apps.publishPiralDefaults.logLevel)
-        .choices('type', buildTypeKeys)
+        .choices('type', piralBuildTypeKeys)
         .describe('type', 'Selects the target type to publish. "all" publishes all target types.')
         .default('type', apps.publishPiralDefaults.type)
         .choices('provider', availableReleaseProviders)
@@ -482,6 +484,9 @@ const allCommands: Array<ToolCommand<any>> = [
         .choices('bundler', availableBundlers)
         .describe('bundler', 'Sets the bundler to use.')
         .default('bundler', availableBundlers[0])
+        .choices('type', piletBuildTypeKeys)
+        .describe('type', 'Selects the target type of the build.')
+        .default('type', apps.buildPiletDefaults.type)
         .string('app')
         .describe('app', 'Sets the name of the Piral instance.')
         .string('base')
@@ -498,6 +503,7 @@ const allCommands: Array<ToolCommand<any>> = [
         declaration: args.declaration as boolean,
         sourceMaps: args['source-maps'] as boolean,
         optimizeModules: args['optimize-modules'] as boolean,
+        type: args.type as PiletBuildType,
         fresh: args.fresh as boolean,
         logLevel: args['log-level'] as LogLevels,
         schemaVersion: args.schema as PiletSchemaVersion,
@@ -567,6 +573,9 @@ const allCommands: Array<ToolCommand<any>> = [
         .choices('schema', schemaKeys)
         .describe('schema', 'Sets the schema to be used when making a fresh build of the pilet.')
         .default('schema', apps.publishPiletDefaults.schemaVersion)
+        .choices('bundler', availableBundlers)
+        .describe('bundler', 'Sets the bundler to use.')
+        .default('bundler', availableBundlers[0])
         .choices('from', fromKeys)
         .describe('from', 'Sets the type of the source to use for publishing.')
         .default('from', apps.publishPiletDefaults.from)
@@ -584,10 +593,12 @@ const allCommands: Array<ToolCommand<any>> = [
         url: args.url as string,
         logLevel: args['log-level'] as LogLevels,
         cert: args['ca-cert'] as string,
+        bundlerName: args.bundler as string,
         fresh: args.fresh as boolean,
         from: args.from as PiletPublishSource,
         schemaVersion: args.schema as PiletSchemaVersion,
         fields: args.fields as Record<string, string>,
+        _: args,
       });
     },
   },

package/src/common/compatibility.ts

@@ -4,6 +4,12 @@ import { log } from './log';
 
 export function checkAppShellCompatibility(piralVersion: string) {
   log('generalDebug_0003', `Checking compatibility ...`);
+
+  if (!piralVersion) {
+    log('appShellMaybeIncompatible_0102', cliVersion);
+    return false;
+  }
+
   const compatible = findCompatVersion(piralVersion);
   log('generalDebug_0003', `Used versions: "${compatible}" and "${compatVersion}".`);
 

package/src/common/index.ts

@@ -25,4 +25,5 @@ export * from './port';
 export * from './rules';
 export * from './scaffold';
 export * from './scripts';
+export * from './spec';
 export * from './template';

package/src/common/io.ts

@@ -254,7 +254,7 @@ export async function matchAnyPilet(baseDir: string, patterns: Array<string>) {
                   log('generalDebug_0003', `Found a "source" field with value "${source}".`);
                   const target = resolve(targetDir, source);
                   const exists = await checkExists(target);
-  
+
                   if (exists) {
                     log('generalDebug_0003', `Taking existing target as "${target}".`);
                     matched(name, target);
@@ -264,7 +264,7 @@ export async function matchAnyPilet(baseDir: string, patterns: Array<string>) {
                 } else {
                   log('generalDebug_0003', `No "source" field found. Trying combinations in "src".`);
                   const files = await matchPattern(targetDir, `src/index.{${exts}}`);
-  
+
                   if (files.length > 0) {
                     log('generalDebug_0003', `Found a result; taking "${files[0]}".`);
                     matched(name, files[0]);
@@ -420,10 +420,20 @@ export async function copy(source: string, target: string, forceOverwrite = Forc
 
   try {
     const flag = forceOverwrite === ForceOverwrite.yes ? 0 : constants.COPYFILE_EXCL;
-    await new Promise<void>((resolve, reject) => {
-      copyFile(source, target, flag, (err) => (err ? reject(err) : resolve()));
-    });
-    return true;
+    const isDir = await checkIsDirectory(source);
+
+    if (isDir) {
+      const files = await getFileNames(source);
+      const results = await Promise.all(
+        files.map((file) => copy(resolve(source, file), resolve(target, file), forceOverwrite)),
+      );
+      return results.every(Boolean);
+    } else {
+      await new Promise<void>((resolve, reject) => {
+        copyFile(source, target, flag, (err) => (err ? reject(err) : resolve()));
+      });
+      return true;
+    }
   } catch (e) {
     if (forceOverwrite === ForceOverwrite.prompt) {
       const shouldOverwrite = await promptOverwrite(target);

package/src/common/npm.ts

@@ -1,4 +1,4 @@
-import { resolve, relative } from 'path';
+import { resolve, relative, dirname } from 'path';
 import { createReadStream, existsSync, access, constants } from 'fs';
 import { log, fail } from './log';
 import { config } from './config';
@@ -107,23 +107,56 @@ export async function determineNpmClient(root: string, selected?: NpmClientType)
 
 export async function isMonorepoPackageRef(refName: string, root: string): Promise<boolean> {
   const c = require(`./clients/npm`);
-  const details = await c.listPackage(refName, root);
-  return details?.dependencies?.[refName]?.extraneous ?? false;
-}
+  const newRoot = await detectMonorepoRoot(root);
 
-export type MonorepoKind = 'none' | 'lerna' | 'yarn';
+  if (newRoot) {
+    const details = await c.listPackage(refName, newRoot);
+    return details?.dependencies?.[refName]?.extraneous ?? false;
+  }
 
-export async function detectMonorepo(root: string): Promise<MonorepoKind> {
+  return false;
+}
+
+export async function detectMonorepoRoot(root: string): Promise<string> {
   const file = await getLernaConfigPath(root);
 
   if (file !== undefined) {
-    return 'lerna';
+    return dirname(file);
   }
 
-  const packageJson = await readJson(root, 'package.json');
+  let previous = root;
+
+  do {
+    const packageJson = await readJson(root, 'package.json');
+
+    if (Array.isArray(packageJson?.workspaces)) {
+      return root;
+    }
+
+    previous = root;
+    root = dirname(root);
+  } while (root !== previous);
+
+  return undefined;
+}
+
+export type MonorepoKind = 'none' | 'lerna' | 'yarn';
+
+export async function detectMonorepo(root: string): Promise<MonorepoKind> {
+  const newRoot = await detectMonorepoRoot(root);
 
-  if (Array.isArray(packageJson?.workspaces)) {
-    return 'yarn';
+  if (newRoot) {
+    const file = await getLernaConfigPath(newRoot);
+
+    if (file !== undefined) {
+      return 'lerna';
+    }
+
+    const packageJson = await readJson(newRoot, 'package.json');
+
+    if (Array.isArray(packageJson?.workspaces)) {
+      return 'yarn';
+    }
   }
 
   return 'none';
@@ -159,7 +192,7 @@ export function createPackage(target = '.'): Promise<string> {
   return c.createPackage(target);
 }
 
-export function findTarball(packageRef: string) {
+export function findTarball(packageRef: string): Promise<string> {
   const c = require(`./clients/npm`);
   return c.findTarball(packageRef);
 }

package/src/common/spec.ts

@@ -0,0 +1,58 @@
+import { existsSync, readFileSync, statSync } from 'fs';
+import { computeHash, computeIntegrity } from './hash';
+
+const checkV1 = /^\/\/\s*@pilet\s+v:1\s*\(([A-Za-z0-9\_\:\-]+)\)/;
+const checkV2 = /^\/\/\s*@pilet\s+v:2\s*(?:\(([A-Za-z0-9\_\:\-]+),\s*(.*)\))?/;
+
+function getDependencies(deps: string, basePath: string) {
+  try {
+    const depMap = JSON.parse(deps);
+
+    if (depMap && typeof depMap === 'object') {
+      return Object.keys(depMap).reduce((obj, depName) => {
+        const depUrl = depMap[depName];
+
+        if (typeof depUrl === 'string') {
+          const url = new URL(depUrl, basePath);
+          obj[depName] = url.href;
+        }
+
+        return obj;
+      }, {});
+    }
+  } catch {}
+
+  return {};
+}
+
+export function getPiletSpecMeta(target: string, basePath: string) {
+  if (existsSync(target) && statSync(target).isFile()) {
+    const content = readFileSync(target, 'utf8');
+
+    if (checkV1.test(content)) {
+      // uses single argument; requireRef (required)
+      const [, requireRef] = checkV1.exec(content);
+      return {
+        spec: 'v1',
+        requireRef,
+        integrity: computeIntegrity(content),
+      };
+    } else if (checkV2.test(content)) {
+      // uses two arguments; requireRef and dependencies as JSON (required)
+      const [, requireRef, plainDependencies] = checkV2.exec(content);
+      return {
+        spec: 'v2',
+        requireRef,
+        dependencies: getDependencies(plainDependencies, basePath),
+      };
+    } else {
+      return {
+        spec: 'v0',
+        hash: computeHash(content),
+        noCache: true,
+      };
+    }
+  }
+
+  return {};
+}

package/src/helpers.ts

@@ -1,9 +1,17 @@
 import { ForceOverwrite, SourceLanguage } from './common/enums';
-import { Framework, NpmClientType, PiletSchemaVersion, PiletPublishSource, PiralBuildType } from './types';
+import {
+  Framework,
+  NpmClientType,
+  PiletSchemaVersion,
+  PiletPublishSource,
+  PiralBuildType,
+  PiletBuildType,
+} from './types';
 
 export const schemaKeys: Array<PiletSchemaVersion> = ['v0', 'v1', 'v2', 'none'];
 export const fromKeys: Array<PiletPublishSource> = ['local', 'remote', 'npm'];
-export const buildTypeKeys: Array<PiralBuildType> = ['all', 'release', 'emulator', 'emulator-sources'];
+export const piralBuildTypeKeys: Array<PiralBuildType> = ['all', 'release', 'emulator', 'emulator-sources'];
+export const piletBuildTypeKeys: Array<PiletBuildType> = ['default', 'standalone'];
 export const clientTypeKeys: Array<NpmClientType> = ['npm', 'pnpm', 'yarn'];
 export const bundlerKeys: Array<string> = ['none', 'parcel', 'webpack', 'webpack5', 'esbuild'];
 export const availableBundlers: Array<string> = [];

package/src/injectors/pilet.ts

@@ -3,8 +3,8 @@ import { join } from 'path';
 import { EventEmitter } from 'events';
 import { readFileSync, existsSync, statSync } from 'fs';
 import { KrasInjector, KrasResponse, KrasRequest, KrasInjectorConfig, KrasConfiguration, KrasResult } from 'kras';
-import { computeHash, computeIntegrity } from '../common/hash';
 import { log } from '../common/log';
+import { getPiletSpecMeta } from '../common/spec';
 import { axios, mime } from '../external';
 import { Bundler } from '../types';
 
@@ -26,62 +26,6 @@ interface PiletMetadata {
   [key: string]: unknown;
 }
 
-const checkV1 = /^\/\/\s*@pilet\s+v:1\s*\(([A-Za-z0-9\_\:\-]+)\)/;
-const checkV2 = /^\/\/\s*@pilet\s+v:2\s*(?:\(([A-Za-z0-9\_\:\-]+),\s*(.*)\))?/;
-
-function getDependencies(deps: string, basePath: string) {
-  try {
-    const depMap = JSON.parse(deps);
-
-    if (depMap && typeof depMap === 'object') {
-      return Object.keys(depMap).reduce((obj, depName) => {
-        const depUrl = depMap[depName];
-
-        if (typeof depUrl === 'string') {
-          const url = new URL(depUrl, basePath);
-          obj[depName] = url.href;
-        }
-
-        return obj;
-      }, {});
-    }
-  } catch {}
-
-  return {};
-}
-
-function getPiletSpecMeta(target: string, basePath: string) {
-  if (existsSync(target) && statSync(target).isFile()) {
-    const content = readFileSync(target, 'utf8');
-
-    if (checkV1.test(content)) {
-      // uses single argument; requireRef (required)
-      const [, requireRef] = checkV1.exec(content);
-      return {
-        spec: 'v1',
-        requireRef,
-        integrity: computeIntegrity(content),
-      };
-    } else if (checkV2.test(content)) {
-      // uses two arguments; requireRef and dependencies as JSON (required)
-      const [, requireRef, plainDependencies] = checkV2.exec(content);
-      return {
-        spec: 'v2',
-        requireRef,
-        dependencies: getDependencies(plainDependencies, basePath),
-      };
-    } else {
-      return {
-        spec: 'v0',
-        hash: computeHash(content),
-        noCache: true,
-      };
-    }
-  }
-
-  return {};
-}
-
 function fillPiletMeta(pilet: Pilet, basePath: string) {
   const { root, bundler } = pilet;
   const def = JSON.parse(readFileSync(join(root, 'package.json'), 'utf8'));
@@ -100,6 +44,24 @@ function fillPiletMeta(pilet: Pilet, basePath: string) {
   return JSON.stringify(meta);
 }
 
+async function loadFeed(feed: string) {
+  try {
+    const response = await axios.default.get<{ items?: Array<PiletMetadata> } | Array<PiletMetadata> | PiletMetadata>(
+      feed,
+    );
+
+    if (Array.isArray(response.data)) {
+      return response.data;
+    } else if (Array.isArray(response.data?.items)) {
+      return response.data.items;
+    } else {
+      return [response.data];
+    }
+  } catch (e) {
+    log('generalWarning_0001', `Couldn't load feed at ${feed}.`);
+  }
+}
+
 export default class PiletInjector implements KrasInjector {
   public config: PiletInjectorConfig;
   private piletApi: string;
@@ -165,35 +127,26 @@ export default class PiletInjector implements KrasInjector {
     return JSON.stringify(mergedPilets);
   }
 
-  async loadRemoteFeed(feed?: string): Promise<Array<PiletMetadata>> {
+  async loadRemoteFeed(feed?: string | Array<string>): Promise<Array<Array<PiletMetadata>>> {
     if (feed) {
-      try {
-        const response = await axios.default.get<{ items?: Array<PiletMetadata> } | Array<PiletMetadata> | PiletMetadata>(feed);
-  
-        if (Array.isArray(response.data)) {
-          return response.data;
-        } else if (Array.isArray(response.data?.items)) {
-          return response.data.items;
-        } else {
-          return [response.data];
-        }
-      } catch (e) {
-        log('generalWarning_0001', `Couldn't load feed at ${feed}.`);
-      }
+      const feeds = Array.isArray(feed) ? feed : [feed];
+      return await Promise.all(feeds.map(loadFeed));
     }
-
   }
 
-  mergePilets(localPilets: Array<PiletMetadata>, remotePilets: Array<PiletMetadata>) {
-    if (!remotePilets) {
+  mergePilets(localPilets: Array<PiletMetadata>, remoteFeeds: Array<Array<PiletMetadata>>) {
+    if (!remoteFeeds) {
       return localPilets;
     }
 
     const names = localPilets.map((pilet) => pilet.name);
-    const merged = [
-      ...localPilets,
-      ...remotePilets.filter((pilet) => pilet.name !== undefined && !names.includes(pilet.name)),
-    ];
+    const merged = [...localPilets];
+
+    for (const remotePilets of remoteFeeds) {
+      const newPilets = remotePilets.filter((pilet) => pilet.name !== undefined && !names.includes(pilet.name));
+      names.push(...newPilets.map((p) => p.name));
+      merged.push(...newPilets);
+    }
 
     return merged;
   }