piral-cli 0.14.2 → 0.14.3-beta.3299

package/src/apps/build-pilet.ts

@@ -1,6 +1,6 @@
 import { dirname, basename, resolve, relative } from 'path';
-import { LogLevels, PiletSchemaVersion } from '../types';
-import { callPiletBuild } from '../bundler';
+import { LogLevels, PiletBuildType, PiletSchemaVersion } from '../types';
+import { callPiletBuild, callPiralBuild } from '../bundler';
 import {
   removeDirectory,
   retrievePiletData,
@@ -13,6 +13,13 @@ import {
   matchAnyPilet,
   fail,
   config,
+  log,
+  createDirectory,
+  writeJson,
+  getPiletSpecMeta,
+  getFileNames,
+  copy,
+  checkAppShellPackage,
 } from '../common';
 
 export interface BuildPiletOptions {
@@ -25,7 +32,7 @@ export interface BuildPiletOptions {
    * The source index file (e.g. index.tsx) for collecting all the information
    * @example './src/index'
    */
-  entry?: string;
+  entry?: string | Array<string>;
 
   /**
    * The target file of bundling.
@@ -68,6 +75,11 @@ export interface BuildPiletOptions {
    */
   contentHash?: boolean;
 
+  /**
+   * Selects the target type of the build (e.g. 'release'). "all" builds all target types.
+   */
+  type?: PiletBuildType;
+
   /**
    * States if the node modules should be included for target transpilation
    */
@@ -97,11 +109,45 @@ export interface BuildPiletOptions {
   };
 }
 
+interface PiletData {
+  id: string;
+  package: any;
+  path: string;
+  outFile: string;
+  outDir: string;
+}
+
+function createMetadata(outDir: string, outFile: string, pilets: Array<PiletData>) {
+  return writeJson(
+    outDir,
+    outFile,
+    pilets.map((p) => ({
+      name: p.package.name,
+      version: p.package.version,
+      link: `./${p.id}/${p.outFile}`,
+      ...getPiletSpecMeta(p.path, p.outDir),
+    })),
+  );
+}
+
+function copyPilets(outDir: string, pilets: Array<PiletData>) {
+  return Promise.all(
+    pilets.map(async (p) => {
+      const files = await getFileNames(p.outDir);
+
+      for (const file of files) {
+        await copy(resolve(p.outDir, file), resolve(outDir, p.id, file), ForceOverwrite.yes);
+      }
+    }),
+  );
+}
+
 export const buildPiletDefaults: BuildPiletOptions = {
   entry: './src/index',
   target: './dist/index.js',
   minify: true,
   logLevel: LogLevels.info,
+  type: 'default',
   fresh: false,
   sourceMaps: true,
   contentHash: true,
@@ -122,70 +168,158 @@ export async function buildPilet(baseDir = process.cwd(), options: BuildPiletOpt
     optimizeModules = buildPiletDefaults.optimizeModules,
     schemaVersion = buildPiletDefaults.schemaVersion,
     declaration = buildPiletDefaults.declaration,
+    type = buildPiletDefaults.type,
     _ = {},
     hooks = {},
     bundlerName,
     app,
   } = options;
   const fullBase = resolve(process.cwd(), baseDir);
+  const entryList = Array.isArray(entry) ? entry : [entry];
   setLogLevel(logLevel);
 
   await hooks.onBegin?.({ options, fullBase });
   progress('Reading configuration ...');
-  const allEntries = await matchAnyPilet(fullBase, [entry]);
+  const allEntries = await matchAnyPilet(fullBase, entryList);
+  log('generalDebug_0003', `Found the following entries: ${allEntries.join(', ')}`);
 
   if (allEntries.length === 0) {
     fail('entryFileMissing_0077');
   }
 
-  const entryModule = allEntries.shift();
-  const targetDir = dirname(entryModule);
-  const { peerDependencies, peerModules, root, appPackage, piletPackage, ignored, importmap } = await retrievePiletData(
-    targetDir,
-    app,
+  const pilets = await Promise.all(
+    allEntries.map(async (entryModule) => {
+      const targetDir = dirname(entryModule);
+      const { peerDependencies, peerModules, root, appPackage, appFile, piletPackage, ignored, importmap } =
+        await retrievePiletData(targetDir, app);
+      const externals = [...Object.keys(peerDependencies), ...peerModules];
+      const dest = resolve(root, target);
+      const outDir = dirname(dest);
+      const outFile = basename(dest);
+
+      if (fresh) {
+        progress('Removing output directory ...');
+        await removeDirectory(outDir);
+      }
+
+      logInfo('Bundle pilet ...');
+
+      await hooks.beforeBuild?.({ root, outDir, importmap, entryModule, schemaVersion, piletPackage });
+
+      await callPiletBuild(
+        {
+          root,
+          piral: appPackage.name,
+          optimizeModules,
+          sourceMaps,
+          contentHash,
+          minify,
+          externals,
+          targetDir,
+          importmap,
+          outFile,
+          outDir,
+          entryModule: `./${relative(root, entryModule)}`,
+          logLevel,
+          version: schemaVersion,
+          ignored,
+          _,
+        },
+        bundlerName,
+      );
+
+      await hooks.afterBuild?.({ root, outDir, importmap, entryModule, schemaVersion, piletPackage });
+
+      if (declaration) {
+        await hooks.beforeDeclaration?.({ root, outDir, entryModule, piletPackage });
+        await createPiletDeclaration(
+          piletPackage.name,
+          root,
+          entryModule,
+          externals,
+          outDir,
+          ForceOverwrite.yes,
+          logLevel,
+        );
+        await hooks.afterDeclaration?.({ root, outDir, entryModule, piletPackage });
+      }
+
+      logDone(`Pilet "${piletPackage.name}" built successfully!`);
+
+      return {
+        id: piletPackage.name.replace(/[^a-zA-Z0-9\-]/gi, ''),
+        root,
+        appFile,
+        appPackage,
+        outDir,
+        outFile,
+        path: dest,
+        package: piletPackage,
+      };
+    }),
   );
-  const externals = [...Object.keys(peerDependencies), ...peerModules];
-  const outDir = dirname(resolve(fullBase, target));
 
-  if (fresh) {
-    progress('Removing output directory ...');
+  if (type === 'standalone') {
+    const distDir = dirname(resolve(fullBase, target));
+    const outDir = resolve(distDir, 'standalone');
+    const { appFile, appPackage, root } = pilets[0];
+    const isEmulator = checkAppShellPackage(appPackage);
+
+    logInfo('Building standalone solution ...');
+
     await removeDirectory(outDir);
-  }
 
-  logInfo('Bundle pilet ...');
-
-  await hooks.beforeBuild?.({ root, outDir, importmap, entryModule, schemaVersion, piletPackage });
-
-  await callPiletBuild(
-    {
-      root,
-      piral: appPackage.name,
-      optimizeModules,
-      sourceMaps,
-      contentHash,
-      minify,
-      externals,
-      targetDir,
-      importmap,
-      outFile: basename(target),
-      outDir,
-      entryModule: `./${relative(root, entryModule)}`,
-      logLevel,
-      version: schemaVersion,
-      ignored,
-      _,
-    },
-    bundlerName,
-  );
+    progress('Copying files ...');
+
+    await copyPilets(outDir, pilets);
+
+    await createMetadata(outDir, '$pilet-api', pilets);
+
+    if (isEmulator) {
+      // in case of an emulator assets are not "seen" by the bundler, so we
+      // just copy overthing over - this should work in most cases.
+      await copy(dirname(appFile), outDir, ForceOverwrite.yes);
+    }
+
+    progress('Optimizing app shell ...');
+
+    await callPiralBuild(
+      {
+        root,
+        piral: appPackage.name,
+        emulator: false,
+        standalone: true,
+        optimizeModules: false,
+        sourceMaps,
+        contentHash,
+        minify,
+        externals: [],
+        publicUrl: '/',
+        outFile: 'index.html',
+        outDir,
+        entryFiles: appFile,
+        logLevel,
+        ignored: [],
+        _,
+      },
+      bundlerName,
+    );
+
+    logDone(`Standalone app available at "${outDir}"!`);
+  } else if (type === 'manifest') {
+    const manifest = 'pilets.json';
+    const outDir = dirname(resolve(fullBase, target));
+
+    logInfo('Building pilet manifest ...');
+
+    progress('Copying files ...');
+
+    await copyPilets(outDir, pilets);
 
-  await hooks.afterBuild?.({ root, outDir, importmap, entryModule, schemaVersion, piletPackage });
+    await createMetadata(outDir, manifest, pilets);
 
-  if (declaration) {
-    await hooks.beforeDeclaration?.({ root, outDir, entryModule, piletPackage });
-    await createPiletDeclaration(piletPackage.name, root, entryModule, externals, outDir, ForceOverwrite.yes, logLevel);
-    await hooks.afterDeclaration?.({ root, outDir, entryModule, piletPackage });
+    logDone(`Manifest available at "${outDir}/${manifest}"!`);
   }
 
-  logDone('Pilet built successfully!');
-  await hooks.onEnd?.({ root });
+  await hooks.onEnd?.({});
 }

package/src/apps/build-piral.ts

@@ -199,6 +199,7 @@ export async function buildPiral(baseDir = process.cwd(), options: BuildPiralOpt
         root,
         piral: name,
         emulator: true,
+        standalone: false,
         optimizeModules,
         sourceMaps,
         contentHash,
@@ -219,11 +220,11 @@ export async function buildPiral(baseDir = process.cwd(), options: BuildPiralOpt
 
     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) {
@@ -247,7 +248,7 @@ export async function buildPiral(baseDir = process.cwd(), options: BuildPiralOpt
     await removeDirectory(targetDir);
 
     logInfo(`Bundle ${releaseName} ...`);
-    
+
     await hooks.beforeBuild?.({ root, publicUrl, externals, entryFiles, targetDir, name });
 
     const { dir: outDir, name: outFile, hash } = await callPiralBuild(
@@ -255,6 +256,7 @@ export async function buildPiral(baseDir = process.cwd(), options: BuildPiralOpt
         root,
         piral: name,
         emulator: false,
+        standalone: false,
         optimizeModules,
         sourceMaps,
         contentHash,
@@ -270,7 +272,7 @@ 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');

package/src/apps/debug-pilet.ts

@@ -65,9 +65,9 @@ export interface DebugPiletOptions {
   schemaVersion?: PiletSchemaVersion;
 
   /**
-   * The URL of a pilet feed used to include locally missing pilets.
+   * The URL of a pilet feed(s) used to include locally missing pilets.
    */
-  feed?: string;
+  feed?: string | Array<string>;
 
   /**
    * Additional arguments for a specific bundler.

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/run-build-piral.ts

@@ -7,6 +7,7 @@ function run(
   root: string,
   piral: string,
   emulator: boolean,
+  standalone: boolean,
   sourceMaps: boolean,
   contentHash: boolean,
   minify: boolean,
@@ -22,7 +23,7 @@ function run(
     production: !emulator,
     root,
     debugPiral: emulator,
-    debugPilet: emulator,
+    debugPilet: emulator || standalone,
     piral,
     dependencies: externals,
   });
@@ -56,6 +57,7 @@ process.on('message', async (msg) => {
           process.cwd(),
           msg.piral,
           msg.emulator,
+          msg.standalone,
           msg.sourceMaps,
           msg.contentHash,
           msg.minify,

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';