piral-cli 0.14.2 → 0.14.3-beta.3295

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,12 @@ import {
   matchAnyPilet,
   fail,
   config,
+  log,
+  createDirectory,
+  writeJson,
+  getPiletSpecMeta,
+  getFileNames,
+  copy,
 } from '../common';
 
 export interface BuildPiletOptions {
@@ -25,7 +31,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 +74,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
    */
@@ -102,6 +113,7 @@ export const buildPiletDefaults: BuildPiletOptions = {
   target: './dist/index.js',
   minify: true,
   logLevel: LogLevels.info,
+  type: 'default',
   fresh: false,
   sourceMaps: true,
   contentHash: true,
@@ -122,70 +134,146 @@ 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 externals = [...Object.keys(peerDependencies), ...peerModules];
-  const outDir = dirname(resolve(fullBase, target));
+  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);
-  }
+      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: basename(target),
-      outDir,
-      entryModule: `./${relative(root, entryModule)}`,
-      logLevel,
-      version: schemaVersion,
-      ignored,
-      _,
-    },
-    bundlerName,
+      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,
+      };
+    }),
   );
 
-  await hooks.afterBuild?.({ root, outDir, importmap, entryModule, schemaVersion, piletPackage });
+  if (type === 'standalone') {
+    const outDir = resolve(fullBase, target, 'standalone');
+    const { appFile, appPackage, root } = pilets[0];
+    await createDirectory(outDir);
+
+    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);
+        }
+      }),
+    );
+
+    await callPiralBuild(
+      {
+        root,
+        piral: appPackage.name,
+        emulator: false,
+        optimizeModules: false,
+        sourceMaps,
+        contentHash,
+        minify,
+        externals: [],
+        publicUrl: '/',
+        outFile: 'index.html',
+        outDir,
+        entryFiles: appFile,
+        logLevel,
+        ignored: [],
+        _,
+      },
+      bundlerName,
+    );
+
+    await writeJson(
+      outDir,
+      '$pilet-api',
+      pilets.map((p) => ({
+        name: p.package.name,
+        version: p.package.version,
+        link: `./${p.id}/${p.outFile}`,
+        ...getPiletSpecMeta(p.path, p.outDir),
+      })),
+    );
 
-  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(`Standalone app available at "${outDir}"!`);
   }
 
-  logDone('Pilet built successfully!');
-  await hooks.onEnd?.({ root });
+  await hooks.onEnd?.({});
 }

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

@@ -23,7 +23,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.
@@ -83,7 +83,7 @@ export const publishPiletDefaults: PublishPiletOptions = {
 
 async function getFiles(
   baseDir: string,
-  source: string,
+  sources: Array<string>,
   from: PiletPublishSource,
   fresh: boolean,
   schemaVersion: PiletSchemaVersion,
@@ -107,17 +107,23 @@ async function getFiles(
     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], []);
+      }
     }
   }
 }
@@ -153,12 +159,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, 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/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,

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]);

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> = [];