piral-cli 0.14.2-beta.3272 → 0.14.3-beta.3297

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

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