piral-cli 0.13.8 → 0.14.0-beta.3156

package/src/build/run-debug-mono-piral.ts

@@ -0,0 +1,87 @@
+import type { LogLevels, PiralBuildHandler } from '../types';
+import { setStandardEnvs, progress, logReset } from '../common';
+import { resolve } from 'path';
+
+let handler: PiralBuildHandler;
+
+function run(
+  root: string,
+  outFile: string,
+  outDir: string,
+  piral: string,
+  hmr: boolean,
+  externals: Array<string>,
+  entryFiles: string,
+  logLevel: LogLevels,
+  args: any,
+) {
+  progress(`Preparing supplied Piral instance ...`);
+
+  setStandardEnvs({
+    piral,
+    dependencies: externals,
+    production: false,
+    debugPiral: true,
+    debugPilet: true,
+    root,
+  });
+
+  return handler.create({
+    root,
+    entryFiles,
+    outFile,
+    outDir,
+    externals,
+    emulator: true,
+    sourceMaps: true,
+    contentHash: false,
+    minify: false,
+    publicUrl: undefined,
+    hmr,
+    logLevel,
+    watch: true,
+    args,
+  });
+}
+
+process.on('message', async (msg) => {
+  try {
+    switch (msg.type) {
+      case 'init':
+        handler = require(msg.path);
+        break;
+      case 'start':
+        const root = process.cwd();
+        const outDir = resolve(root, 'dist', 'app');
+        const bundler = await run(
+          root,
+          msg.outFile,
+          outDir,
+          msg.piral,
+          true,
+          msg.externals,
+          msg.entryFiles,
+          msg.logLevel,
+          msg,
+        );
+        const result = await bundler.bundle();
+
+        logReset();
+
+        if (result) {
+          process.send({
+            type: 'done',
+            outDir: result.outDir,
+            outFile: result.outFile,
+          });
+        }
+
+        break;
+    }
+  } catch (error) {
+    process.send({
+      type: 'fail',
+      error: error?.message,
+    });
+  }
+});

package/src/build/run-debug-pilet.ts

@@ -0,0 +1,114 @@
+import type {
+  PiletSchemaVersion,
+  LogLevels,
+  SharedDependency,
+  BundleHandlerResponse,
+  PiletBuildHandler,
+} from '../types';
+import { setStandardEnvs } from '../common';
+import { resolve } from 'path';
+
+let handler: PiletBuildHandler;
+let bundler: BundleHandlerResponse;
+
+function run(
+  root: string,
+  targetDir: string,
+  outDir: string,
+  piral: string,
+  externals: Array<string>,
+  importmap: Array<SharedDependency>,
+  entryModule: string,
+  version: PiletSchemaVersion,
+  logLevel: LogLevels,
+  args: any,
+) {
+  setStandardEnvs({
+    piral,
+    root,
+  });
+  return handler.create({
+    root,
+    piral,
+    entryModule,
+    targetDir,
+    outDir,
+    outFile: 'index.js',
+    externals,
+    importmap,
+    version,
+    develop: true,
+    sourceMaps: true,
+    contentHash: true,
+    minify: false,
+    logLevel,
+    watch: true,
+    args,
+  });
+}
+
+process.on('message', async (msg) => {
+  const root = process.cwd();
+
+  try {
+    switch (msg.type) {
+      case 'init':
+        handler = require(msg.path);
+        break;
+      case 'bundle':
+        if (bundler) {
+          await bundler.bundle();
+        }
+
+        break;
+      case 'start':
+        const dist = resolve(root, 'dist');
+        bundler = await run(
+          root,
+          msg.targetDir,
+          dist,
+          msg.piral,
+          msg.externals,
+          msg.importmap,
+          msg.entryModule,
+          msg.version,
+          msg.logLevel,
+          msg,
+        );
+
+        if (bundler) {
+          bundler.onStart(() => {
+            process.send({
+              type: 'pending',
+            });
+          });
+          bundler.onEnd((result) => {
+            if (msg.hmr) {
+              process.send({
+                type: 'update',
+                outHash: result.hash,
+                outName: result.name,
+                args: {
+                  requireRef: result.requireRef,
+                  version: msg.version,
+                  root,
+                },
+              });
+            }
+          });
+
+          process.send({
+            type: 'done',
+            outDir: dist,
+          });
+        }
+
+        break;
+    }
+  } catch (error) {
+    process.send({
+      type: 'fail',
+      error: error?.message,
+    });
+  }
+});

package/src/build/run-debug-piral.ts

@@ -0,0 +1,106 @@
+import type { BundleHandlerResponse, LogLevels, PiralBuildHandler } from '../types';
+import { setStandardEnvs } from '../common';
+import { resolve } from 'path';
+
+let handler: PiralBuildHandler;
+let bundler: BundleHandlerResponse;
+
+function run(
+  root: string,
+  outFile: string,
+  outDir: string,
+  piral: string,
+  hmr: boolean,
+  externals: Array<string>,
+  publicUrl: string,
+  entryFiles: string,
+  logLevel: LogLevels,
+  args: any,
+) {
+  setStandardEnvs({
+    root,
+    debugPiral: true,
+    dependencies: externals,
+    piral,
+  });
+
+  return handler.create({
+    root,
+    entryFiles,
+    outFile,
+    outDir,
+    externals,
+    emulator: true,
+    sourceMaps: true,
+    contentHash: false,
+    minify: false,
+    publicUrl,
+    hmr,
+    logLevel,
+    watch: true,
+    args,
+  });
+}
+
+process.on('message', async (msg) => {
+  const root = process.cwd();
+
+  try {
+    switch (msg.type) {
+      case 'init':
+        handler = require(msg.path);
+        break;
+      case 'bundle':
+        if (bundler) {
+          await bundler.bundle();
+        }
+
+        break;
+      case 'start':
+        const dist = resolve(root, 'dist');
+        bundler = await run(
+          root,
+          msg.outFile,
+          dist,
+          msg.piral,
+          msg.hmr,
+          msg.externals,
+          msg.publicUrl,
+          msg.entryFiles,
+          msg.logLevel,
+          msg,
+        );
+
+        if (bundler) {
+          bundler.onStart(() => {
+            process.send({
+              type: 'pending',
+            });
+          });
+
+          bundler.onEnd((result) => {
+            process.send({
+              type: 'update',
+              outHash: result.hash,
+              outName: 'index.html',
+              args: {
+                root,
+              },
+            });
+          });
+
+          process.send({
+            type: 'done',
+            outDir: dist,
+          });
+        }
+
+        break;
+    }
+  } catch (error) {
+    process.send({
+      type: 'fail',
+      error: error?.message,
+    });
+  }
+});

package/src/bundler.test.ts

@@ -6,50 +6,60 @@ import {
   callPiralDebug,
   callDebugPiralFromMonoRepo,
 } from './bundler';
+import { callDynamic, callStatic } from './build/bundler-calls';
+import * as common from './common';
 
-let common: any;
-let defaults = {
+const defaults = {
   bundler: false,
 };
 
+jest.mock('./build/bundler-calls.ts', () => ({
+  callDynamic: jest.fn(() =>
+    Promise.resolve({
+      bundle: {},
+    }),
+  ),
+  callStatic: jest.fn(() =>
+    Promise.resolve({
+      bundle: {},
+    }),
+  ),
+}));
+
 jest.mock('./inject', () => ({
   inject() {
     if (defaults.bundler) {
       setBundler({
         name: 'default',
         actions: {
-          buildPilet: { run: jest.fn(() => Promise.resolve({})) },
-          debugPilet: { run: jest.fn(() => Promise.resolve({})) },
-          buildPiral: { run: jest.fn(() => Promise.resolve({})) },
-          debugPiral: { run: jest.fn(() => Promise.resolve({})) },
-          watchPiral: { run: jest.fn(() => Promise.resolve({})) },
+          buildPilet: { path: '' },
+          debugPilet: { path: '' },
+          buildPiral: { path: '' },
+          debugPiral: { path: '' },
+          watchPiral: { path: '' },
         } as any,
       });
     }
   },
 }));
 
-jest.mock(
-  './common',
-  () =>
-    (common = {
-      config: {
-        bundler: 'parcel',
-      },
-      cliVersion: '1.0.0',
-      installPackage: jest.fn(),
-      fail(msg) {
-        throw new Error(msg);
-      },
-      progress() {},
-      log() {},
-      determineNpmClient() {
-        return 'npm';
-      },
-      patchModules: jest.fn(),
-      logReset() {},
-    }),
-);
+jest.mock('./common', () => ({
+  config: {
+    bundler: 'parcel',
+  },
+  cliVersion: '1.0.0',
+  installPackage: jest.fn(),
+  fail(msg) {
+    throw new Error(msg);
+  },
+  progress() {},
+  log() {},
+  determineNpmClient() {
+    return 'npm';
+  },
+  patchModules: jest.fn(),
+  logReset() {},
+}));
 
 describe('Piral CLI Bundler Module', () => {
   it('fails if no default bundler can be installed, but required', async () => {
@@ -64,11 +74,11 @@ describe('Piral CLI Bundler Module', () => {
 
   it('setting the bundler can resolve it properly for call pilet build', async () => {
     const actions = {
-      buildPilet: { run: jest.fn(() => Promise.resolve({})) },
-      debugPilet: { run: jest.fn(() => Promise.resolve({})) },
-      buildPiral: { run: jest.fn(() => Promise.resolve({})) },
-      debugPiral: { run: jest.fn(() => Promise.resolve({})) },
-      watchPiral: { run: jest.fn(() => Promise.resolve({})) },
+      buildPilet: { path: '1' },
+      debugPilet: { path: '2' },
+      buildPiral: { path: '3' },
+      debugPiral: { path: '4' },
+      watchPiral: { path: '5' },
     };
 
     setBundler({
@@ -76,17 +86,18 @@ describe('Piral CLI Bundler Module', () => {
       actions: actions as any,
     });
 
-    await callPiletBuild({ root: undefined } as any, 'foo1');
-    expect(actions.buildPilet.run).toHaveBeenCalled();
+    const args = { root: undefined };
+    await callPiletBuild(args as any, 'foo1');
+    expect(callStatic).toHaveBeenCalledWith('build-pilet', '1', args);
   });
 
   it('setting the bundler with optimize modules calls optimize modules', async () => {
     const actions = {
-      buildPilet: { run: jest.fn(() => Promise.resolve({})) },
-      debugPilet: { run: jest.fn(() => Promise.resolve({})) },
-      buildPiral: { run: jest.fn(() => Promise.resolve({})) },
-      debugPiral: { run: jest.fn(() => Promise.resolve({})) },
-      watchPiral: { run: jest.fn(() => Promise.resolve({})) },
+      buildPilet: { path: '' },
+      debugPilet: { path: '' },
+      buildPiral: { path: '' },
+      debugPiral: { path: '' },
+      watchPiral: { path: '' },
     };
 
     setBundler({
@@ -105,11 +116,11 @@ describe('Piral CLI Bundler Module', () => {
 
   it('setting the bundler can resolve it properly for call piral build', async () => {
     const actions = {
-      buildPilet: { run: jest.fn(() => Promise.resolve({})) },
-      debugPilet: { run: jest.fn(() => Promise.resolve({})) },
-      buildPiral: { run: jest.fn(() => Promise.resolve({})) },
-      debugPiral: { run: jest.fn(() => Promise.resolve({})) },
-      watchPiral: { run: jest.fn(() => Promise.resolve({})) },
+      buildPilet: { path: '1' },
+      debugPilet: { path: '2' },
+      buildPiral: { path: '3' },
+      debugPiral: { path: '4' },
+      watchPiral: { path: '5' },
     };
 
     setBundler({
@@ -117,17 +128,18 @@ describe('Piral CLI Bundler Module', () => {
       actions: actions as any,
     });
 
-    await callPiralBuild({ root: undefined } as any, 'foo2');
-    expect(actions.buildPiral.run).toHaveBeenCalled();
+    const args = { root: undefined };
+    await callPiralBuild(args as any, 'foo2');
+    expect(callStatic).toHaveBeenCalledWith('build-piral', '3', args);
   });
 
   it('setting the bundler can resolve it properly for call pilet debug', async () => {
     const actions = {
-      buildPilet: { run: jest.fn(() => Promise.resolve({})) },
-      debugPilet: { run: jest.fn(() => Promise.resolve({})) },
-      buildPiral: { run: jest.fn(() => Promise.resolve({})) },
-      debugPiral: { run: jest.fn(() => Promise.resolve({})) },
-      watchPiral: { run: jest.fn(() => Promise.resolve({})) },
+      buildPilet: { path: '0' },
+      debugPilet: { path: '1' },
+      buildPiral: { path: '2' },
+      debugPiral: { path: '3' },
+      watchPiral: { path: '4' },
     };
 
     setBundler({
@@ -135,17 +147,18 @@ describe('Piral CLI Bundler Module', () => {
       actions: actions as any,
     });
 
-    await callPiletDebug({ root: undefined } as any, 'foo3');
-    expect(actions.debugPilet.run).toHaveBeenCalled();
+    const args = { root: undefined };
+    await callPiletDebug(args as any, 'foo3');
+    expect(callDynamic).toHaveBeenCalledWith('debug-pilet', '1', args);
   });
 
   it('setting the bundler can resolve it properly for call piral debug', async () => {
     const actions = {
-      buildPilet: { run: jest.fn(() => Promise.resolve({})) },
-      debugPilet: { run: jest.fn(() => Promise.resolve({})) },
-      buildPiral: { run: jest.fn(() => Promise.resolve({})) },
-      debugPiral: { run: jest.fn(() => Promise.resolve({})) },
-      watchPiral: { run: jest.fn(() => Promise.resolve({})) },
+      buildPilet: { path: '7' },
+      debugPilet: { path: '8' },
+      buildPiral: { path: '9' },
+      debugPiral: { path: '10' },
+      watchPiral: { path: '11' },
     };
 
     setBundler({
@@ -153,17 +166,18 @@ describe('Piral CLI Bundler Module', () => {
       actions: actions as any,
     });
 
-    await callPiralDebug({ root: undefined } as any, 'foo4');
-    expect(actions.debugPiral.run).toHaveBeenCalled();
+    const args = { root: undefined };
+    await callPiralDebug(args as any, 'foo4');
+    expect(callDynamic).toHaveBeenCalledWith('debug-piral', '10', args);
   });
 
   it('setting the bundler can resolve it properly for call piral watch', async () => {
     const actions = {
-      buildPilet: { run: jest.fn(() => Promise.resolve({})) },
-      debugPilet: { run: jest.fn(() => Promise.resolve({})) },
-      buildPiral: { run: jest.fn(() => Promise.resolve({})) },
-      debugPiral: { run: jest.fn(() => Promise.resolve({})) },
-      watchPiral: { run: jest.fn(() => Promise.resolve({})) },
+      buildPilet: { path: '3' },
+      debugPilet: { path: '4' },
+      buildPiral: { path: '5' },
+      debugPiral: { path: '6' },
+      watchPiral: { path: '7' },
     };
 
     setBundler({
@@ -171,8 +185,9 @@ describe('Piral CLI Bundler Module', () => {
       actions: actions as any,
     });
 
-    await callDebugPiralFromMonoRepo({ root: undefined } as any, 'foo5');
-    expect(actions.watchPiral.run).toHaveBeenCalled();
+    const args = { root: undefined };
+    await callDebugPiralFromMonoRepo(args as any, 'foo5');
+    expect(callStatic).toHaveBeenCalledWith('debug-mono-piral', '7', args);
   });
 
   it('using a non-available bundler should fail', () => {

package/src/bundler.ts

@@ -1,3 +1,4 @@
+import { callDynamic, callStatic } from './build/bundler-calls';
 import { availableBundlers } from './helpers';
 import {
   installPackage,
@@ -20,6 +21,7 @@ import {
   DebugPiletParameters,
   BundlerDefinition,
   BaseBundleParameters,
+  BaseBundlerDefinition,
 } from './types';
 
 export interface QualifiedBundler {
@@ -76,12 +78,18 @@ async function findBundler(root: string, bundlerName?: string) {
   return defaultBundler;
 }
 
-async function prepareModules(args: BaseBundleParameters) {
+async function prepareArgs<T extends BaseBundleParameters>(bundler: BaseBundlerDefinition<T>, args: T): Promise<T> {
   if (args.optimizeModules) {
     progress('Preparing modules ...');
     await patchModules(args.root, args.ignored);
     logReset();
   }
+
+  if (bundler.prepare) {
+    return await bundler.prepare(args);
+  }
+
+  return args;
 }
 
 export function setBundler(bundler: QualifiedBundler) {
@@ -94,26 +102,52 @@ export function setBundler(bundler: QualifiedBundler) {
 
 export async function callPiralDebug(args: DebugPiralParameters, bundlerName?: string): Promise<Bundler> {
   const bundler = await findBundler(args.root, bundlerName);
-  await prepareModules(args);
-  return await bundler.actions.debugPiral.run(args).catch((err) => fail('bundlingFailed_0174', err));
+
+  try {
+    const action = bundler.actions.debugPiral;
+    const params = await prepareArgs(action, args);
+    return await callDynamic('debug-piral', action.path, params);
+  } catch (err) {
+    fail('bundlingFailed_0174', err);
+  }
 }
 
 export async function callPiletDebug(args: DebugPiletParameters, bundlerName?: string): Promise<Bundler> {
   const bundler = await findBundler(args.root, bundlerName);
-  await prepareModules(args);
-  return await bundler.actions.debugPilet.run(args).catch((err) => fail('bundlingFailed_0174', err));
+
+  try {
+    const action = bundler.actions.debugPilet;
+    const params = await prepareArgs(action, args);
+    return await callDynamic('debug-pilet', action.path, params);
+  } catch (err) {
+    fail('bundlingFailed_0174', err);
+  }
 }
 
 export async function callPiralBuild(args: BuildPiralParameters, bundlerName?: string): Promise<BundleDetails> {
   const bundler = await findBundler(args.root, bundlerName);
-  await prepareModules(args);
-  return await bundler.actions.buildPiral.run(args).catch((err) => fail('bundlingFailed_0174', err));
+
+  try {
+    const action = bundler.actions.buildPiral;
+    const params = await prepareArgs(action, args);
+    const instance = await callStatic('build-piral', action.path, params);
+    return instance.bundle;
+  } catch (err) {
+    fail('bundlingFailed_0174', err);
+  }
 }
 
 export async function callPiletBuild(args: BuildPiletParameters, bundlerName?: string): Promise<BundleDetails> {
   const bundler = await findBundler(args.root, bundlerName);
-  await prepareModules(args);
-  return await bundler.actions.buildPilet.run(args).catch((err) => fail('bundlingFailed_0174', err));
+
+  try {
+    const action = bundler.actions.buildPilet;
+    const params = await prepareArgs(action, args);
+    const instance = await callStatic('build-pilet', action.path, params);
+    return instance.bundle;
+  } catch (err) {
+    fail('bundlingFailed_0174', err);
+  }
 }
 
 export async function callDebugPiralFromMonoRepo(
@@ -121,7 +155,13 @@ export async function callDebugPiralFromMonoRepo(
   bundlerName?: string,
 ): Promise<BundleDetails> {
   const bundler = await findBundler(args.root, bundlerName);
-  await prepareModules(args);
-  const { bundle } = await bundler.actions.watchPiral.run(args).catch((err) => fail('bundlingFailed_0174', err));
-  return bundle;
+
+  try {
+    const action = bundler.actions.watchPiral;
+    const params = await prepareArgs(action, args);
+    const instance = await callStatic('debug-mono-piral', action.path, params);
+    return instance.bundle;
+  } catch (err) {
+    fail('bundlingFailed_0174', err);
+  }
 }

package/src/common/config.ts

@@ -1,5 +1,5 @@
 import { rc } from '../external';
-import { NpmClientType } from '../types';
+import { NpmClientType, PiletSchemaVersion } from '../types';
 
 export interface PiralCliConfig {
   /**
@@ -37,6 +37,10 @@ export interface PiralCliConfig {
    * Sets the validators configuration for a Piral instance.
    */
   validators?: Record<string, any>;
+  /**
+   * Sets the schema version to be used for pilets.
+   */
+  schemaVersion?: PiletSchemaVersion;
 }
 
 export const config: PiralCliConfig = rc('piral', {
@@ -48,4 +52,5 @@ export const config: PiralCliConfig = rc('piral', {
   bundler: 'webpack',
   piletApi: '/$pilet-api',
   validators: {},
+  schemaVersion: 'v2',
 });

package/src/common/constants.ts

@@ -4,7 +4,7 @@ export const filesOnceTar = 'files_once';
 export const piralBaseRoot = 'piral-base/lib/types';
 export const entryModuleExtensions = ['.ts', '.tsx', '.js', '.jsx'];
 export const declarationEntryExtensions = ['.html', '.pug', ...entryModuleExtensions];
-export const coreExternals = [
+export const legacyCoreExternals = [
   '@dbeining/react-atom',
   '@libre/atom',
   'history',