piral-cli 1.0.0-pre.2217 → 1.0.0

package/src/apps/build-pilet.ts

@@ -1,16 +1,66 @@
-import { join, dirname, basename, resolve } from 'path';
-import { LogLevels, PiletSchemaVersion } from '../types';
-import { callPiletBuild } from '../bundler';
+import { dirname, basename, resolve, relative } from 'path';
+import { LogLevels, PiletBuildType, PiletSchemaVersion } from '../types';
+import { callPiletBuild, callPiralBuild } from '../bundler';
 import {
   removeDirectory,
-  findEntryModule,
   retrievePiletData,
   setLogLevel,
   progress,
   logDone,
   logInfo,
+  createPiletDeclaration,
+  ForceOverwrite,
+  matchAnyPilet,
+  fail,
+  config,
+  log,
+  writeJson,
+  getPiletSpecMeta,
+  getFileNames,
+  copy,
+  checkAppShellPackage,
+  cpuCount,
+  concurrentWorkers,
+  normalizePublicUrl,
+  combinePiletExternals,
+  retrievePiletsInfo,
+  validateSharedDependencies,
+  defaultSchemaVersion,
 } from '../common';
 
+interface PiletData {
+  id: string;
+  package: any;
+  path: string;
+  outFile: string;
+  outDir: string;
+}
+
+function createMetadata(outDir: string, outFile: string, pilets: Array<PiletData>, publicPath: string) {
+  return writeJson(
+    outDir,
+    outFile,
+    pilets.map((p) => ({
+      name: p.package.name,
+      version: p.package.version,
+      link: `${publicPath}${p.id}/${p.outFile}`,
+      ...getPiletSpecMeta(p.path, `${publicPath}${p.id}/`),
+    })),
+  );
+}
+
+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 interface BuildPiletOptions {
   /**
    * Sets the name of the Piral instance.
@@ -21,7 +71,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.
@@ -29,11 +79,26 @@ export interface BuildPiletOptions {
    */
   target?: string;
 
+  /**
+   * Sets the public URL (path) of the bundle. Only for release output.
+   */
+  publicUrl?: string;
+
   /**
    * States if minifaction or other post-bundle transformations should be performed.
    */
   minify?: boolean;
 
+  /**
+   * Indicates if a declaration file should be generated.
+   */
+  declaration?: boolean;
+
+  /**
+   * Sets the maximum number of parallel build processes.
+   */
+  concurrency?: number;
+
   /**
    * Sets the log level to use (1-5).
    */
@@ -49,6 +114,11 @@ export interface BuildPiletOptions {
    */
   sourceMaps?: boolean;
 
+  /**
+   * States if the build should run continuously and re-build when files change.
+   */
+  watch?: boolean;
+
   /**
    * Sets the bundler to use for building, if any specific.
    */
@@ -59,6 +129,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
    */
@@ -74,71 +149,244 @@ export interface BuildPiletOptions {
    * Additional arguments for a specific bundler.
    */
   _?: Record<string, any>;
+
+  /**
+   * Hooks to be triggered at various stages.
+   */
+  hooks?: {
+    onBegin?(e: any): Promise<void>;
+    beforeBuild?(e: any): Promise<void>;
+    afterBuild?(e: any): Promise<void>;
+    beforeDeclaration?(e: any): Promise<void>;
+    afterDeclaration?(e: any): Promise<void>;
+    onEnd?(e: any): Promise<void>;
+  };
 }
 
 export const buildPiletDefaults: BuildPiletOptions = {
   entry: './src/index',
   target: './dist/index.js',
+  publicUrl: '/',
   minify: true,
   logLevel: LogLevels.info,
+  type: 'default',
   fresh: false,
   sourceMaps: true,
+  watch: false,
   contentHash: true,
   optimizeModules: false,
-  schemaVersion: 'v1',
+  schemaVersion: undefined,
+  concurrency: cpuCount,
+  declaration: true,
 };
 
 export async function buildPilet(baseDir = process.cwd(), options: BuildPiletOptions = {}) {
   const {
     entry = buildPiletDefaults.entry,
     target = buildPiletDefaults.target,
+    publicUrl: originalPublicUrl = buildPiletDefaults.publicUrl,
+    logLevel = buildPiletDefaults.logLevel,
     minify = buildPiletDefaults.minify,
     sourceMaps = buildPiletDefaults.sourceMaps,
+    watch = buildPiletDefaults.watch,
     contentHash = buildPiletDefaults.contentHash,
-    logLevel = buildPiletDefaults.logLevel,
     fresh = buildPiletDefaults.fresh,
+    concurrency = buildPiletDefaults.concurrency,
     optimizeModules = buildPiletDefaults.optimizeModules,
-    schemaVersion = buildPiletDefaults.schemaVersion,
+    schemaVersion: originalSchemaVersion = buildPiletDefaults.schemaVersion,
+    declaration = buildPiletDefaults.declaration,
+    type = buildPiletDefaults.type,
     _ = {},
+    hooks = {},
     bundlerName,
     app,
   } = options;
+  const publicUrl = normalizePublicUrl(originalPublicUrl);
+  const fullBase = resolve(process.cwd(), baseDir);
+  const entryList = Array.isArray(entry) ? entry : [entry];
   setLogLevel(logLevel);
+
+  await hooks.onBegin?.({ options, fullBase });
   progress('Reading configuration ...');
-  const entryFile = join(baseDir, entry);
-  const targetDir = dirname(entryFile);
-  const entryModule = await findEntryModule(entryFile, targetDir);
-  const { peerDependencies, peerModules, root, appPackage, ignored } = await retrievePiletData(targetDir, app);
-  const externals = [...Object.keys(peerDependencies), ...peerModules];
-  const outDir = dirname(resolve(baseDir, target));
-
-  if (fresh) {
-    progress('Removing output directory ...');
-    await removeDirectory(outDir);
+  const allEntries = await matchAnyPilet(fullBase, entryList);
+  log('generalDebug_0003', `Found the following entries: ${allEntries.join(', ')}`);
+
+  if (allEntries.length === 0) {
+    fail('entryFileMissing_0077');
   }
 
-  logInfo('Bundle pilet ...');
+  const pilets = await concurrentWorkers(allEntries, concurrency, async (entryModule) => {
+    const targetDir = dirname(entryModule);
+    const { peerDependencies, peerModules, root, apps, piletPackage, ignored, importmap, schema } = await retrievePiletData(
+      targetDir,
+      app,
+    );
+    const schemaVersion = originalSchemaVersion || schema || config.schemaVersion || defaultSchemaVersion;
+    const piralInstances = apps.map(m => m.appPackage.name);
+    const externals = combinePiletExternals(piralInstances, peerDependencies, peerModules, importmap);
+    const dest = resolve(root, target);
+    const outDir = dirname(dest);
+    const outFile = basename(dest);
+
+    validateSharedDependencies(importmap);
+
+    if (fresh) {
+      progress('Removing output directory ...');
+      await removeDirectory(outDir);
+    }
+
+    logInfo('Bundle pilet ...');
+
+    await hooks.beforeBuild?.({ root, outDir, importmap, entryModule, schemaVersion, piletPackage });
+
+    await callPiletBuild(
+      {
+        root,
+        piralInstances,
+        optimizeModules,
+        sourceMaps,
+        watch,
+        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 });
+    }
 
-  await callPiletBuild(
-    {
+    logDone(`Pilet "${piletPackage.name}" built successfully!`);
+
+    return {
+      id: piletPackage.name.replace(/[^a-zA-Z0-9\-]/gi, ''),
       root,
-      piral: appPackage.name,
-      optimizeModules,
-      sourceMaps,
-      contentHash,
-      minify,
-      externals,
-      targetDir,
-      outFile: basename(target),
+      apps,
       outDir,
-      entryModule,
-      logLevel,
-      version: schemaVersion,
-      ignored,
-      _,
-    },
-    bundlerName,
-  );
+      outFile,
+      path: dest,
+      package: piletPackage,
+    };
+  });
+
+  if (type === 'standalone') {
+    const distDir = dirname(resolve(fullBase, target));
+    const outDir = resolve(distDir, 'standalone');
+    const { apps, root } = pilets[0];
+
+    if (apps.length === 0) {
+      fail('appInstancesNotGiven_0012');
+    }
+
+    const { appPackage, appFile } = apps[0];
+    const piralInstances = [appPackage.name];
+    const isEmulator = checkAppShellPackage(appPackage);
+
+    logInfo('Building standalone solution ...');
+
+    await removeDirectory(outDir);
+
+    progress('Copying files ...');
+
+    await copyPilets(outDir, pilets);
+
+    await createMetadata(outDir, '$pilet-api', pilets, publicUrl);
+
+    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 ...');
+
+      // we don't need to care about externals or other things that are already
+      // part of the emulator
+      await callPiralBuild(
+        {
+          root,
+          piralInstances,
+          emulator: false,
+          standalone: true,
+          optimizeModules: false,
+          sourceMaps,
+          watch: false,
+          contentHash,
+          minify,
+          externals: [],
+          publicUrl,
+          outFile: 'index.html',
+          outDir,
+          entryFiles: appFile,
+          logLevel,
+          ignored: [],
+          _,
+        },
+        bundlerName,
+      );
+    } else {
+      // in this case we can just do the same steps as if
+      const { ignored, externals } = await retrievePiletsInfo(appFile);
+
+      await callPiralBuild(
+        {
+          root,
+          piralInstances,
+          emulator: false,
+          standalone: true,
+          optimizeModules: false,
+          sourceMaps,
+          watch: false,
+          contentHash,
+          minify,
+          externals: externals.map(m => m.name),
+          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 createMetadata(outDir, manifest, pilets, publicUrl);
+
+    logDone(`Manifest available at "${outDir}/${manifest}"!`);
+  }
 
-  logDone('Pilet built successfully!');
+  await hooks.onEnd?.({});
 }

package/src/apps/build-piral.test.ts

@@ -16,16 +16,21 @@ const defaultPackageJson = (files: Array<any>) => `
       "piral"
     ],
     "dependencies": {
+      "piral-base": "*",
+      "piral-core": "*",
       "piral": "*"
     },
     "scripts": {
       "start": "piral debug",
       "build": "piral build"
     },
+    "importmap": {
+      "imports": {},
+      "inherit": ["piral-base", "piral-core"]
+    },
     "app": "./src/index.html",
     "pilets": {
       "files": ${JSON.stringify(files)},
-      "externals": [],
       "scripts": {
         "build": "npm run build-pilet",
         "start": "npm run debug-pilet"
@@ -43,7 +48,6 @@ const defaultPackageJson = (files: Array<any>) => `
       "@types/react-dom": "latest",
       "@types/react-router": "latest",
       "@types/react-router-dom": "latest",
-      "piral-cli": "*",
       "typescript": "latest"
     }
   }
@@ -60,13 +64,17 @@ const defaultIndexHtml = `
 `;
 
 const defaultIndexTsx = `
-  import { renderInstance } from 'piral';
+  import * as React from 'react';
+  import { render } from 'react-dom';
+  import { createInstance, Piral } from 'piral';
 
-  renderInstance({
+  const instance = createInstance({
     requestPilets() {
       return Promise.resolve([]);
     },
   });
+
+  render(<Piral instance={instance} />, document.querySelector('#app'));
 `;
 
 const tsConfigJson = `
@@ -107,7 +115,7 @@ function scaffoldNewPiralInstance(files: Array<any> = []) {
   writeFileSync(resolve(dir, 'src/index.html'), defaultIndexHtml, 'utf8');
   writeFileSync(resolve(dir, 'src/index.tsx'), defaultIndexTsx, 'utf8');
 
-  execSync('npm i', {
+  execSync('npm i --legacy-peer-deps', {
     cwd: dir,
   });
 
@@ -116,12 +124,17 @@ function scaffoldNewPiralInstance(files: Array<any> = []) {
 
 describe('Build Piral Command', () => {
   beforeEach(() => {
+    process.env.NODE_ENV = undefined;
     setBundler({
-      name: 'parcel',
-      actions: require(resolve(__dirname, '../../../piral-cli-parcel/lib/actions')),
+      name: 'webpack5',
+      actions: require(resolve(__dirname, '../../../piral-cli-webpack5/lib/actions')),
     });
   });
 
+  afterEach(() => {
+    process.env.NODE_ENV = 'test';
+  });
+
   it('missing source should result in an error', async () => {
     const dir = createTempDir();
     let error = false;