piral-cli 0.14.0-unstable.3096 → 0.14.1-beta.3244

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

@@ -0,0 +1,89 @@
+import type { PiletSchemaVersion, LogLevels, SharedDependency, PiletBuildHandler } from '../types';
+import { setStandardEnvs } from '../common';
+
+let handler: PiletBuildHandler;
+
+function run(
+  root: string,
+  piral: string,
+  sourceMaps: boolean,
+  contentHash: boolean,
+  minify: boolean,
+  externals: Array<string>,
+  importmap: Array<SharedDependency>,
+  targetDir: string,
+  outDir: string,
+  outFile: string,
+  entryModule: string,
+  version: PiletSchemaVersion,
+  logLevel: LogLevels,
+  args: any,
+) {
+  setStandardEnvs({
+    production: true,
+    piral,
+    root,
+  });
+
+  return handler.create({
+    root,
+    piral,
+    entryModule,
+    targetDir,
+    outDir,
+    outFile,
+    externals,
+    importmap,
+    version,
+    develop: false,
+    sourceMaps,
+    contentHash,
+    minify,
+    logLevel,
+    watch: false,
+    args,
+  });
+}
+
+process.on('message', async (msg) => {
+  try {
+    switch (msg.type) {
+      case 'init':
+        handler = require(msg.path);
+        break;
+      case 'start':
+        const bundler = await run(
+          process.cwd(),
+          msg.piral,
+          msg.sourceMaps,
+          msg.contentHash,
+          msg.minify,
+          msg.externals,
+          msg.importmap,
+          msg.targetDir,
+          msg.outDir,
+          msg.outFile,
+          msg.entryModule,
+          msg.version,
+          msg.logLevel,
+          msg,
+        );
+        const result = await bundler.bundle();
+
+        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-build-piral.ts

@@ -0,0 +1,88 @@
+import type { PiralBuildHandler, LogLevels } from '../types';
+import { setStandardEnvs } from '../common';
+
+let handler: PiralBuildHandler;
+
+function run(
+  root: string,
+  piral: string,
+  emulator: boolean,
+  sourceMaps: boolean,
+  contentHash: boolean,
+  minify: boolean,
+  externals: Array<string>,
+  publicUrl: string,
+  outFile: string,
+  outDir: string,
+  entryFiles: string,
+  logLevel: LogLevels,
+  args: any,
+) {
+  setStandardEnvs({
+    production: !emulator,
+    root,
+    debugPiral: emulator,
+    debugPilet: emulator,
+    piral,
+    dependencies: externals,
+  });
+
+  return handler.create({
+    root,
+    entryFiles,
+    outFile,
+    outDir,
+    externals,
+    emulator,
+    sourceMaps,
+    contentHash,
+    minify,
+    publicUrl,
+    hmr: false,
+    logLevel,
+    watch: false,
+    args,
+  });
+}
+
+process.on('message', async (msg) => {
+  try {
+    switch (msg.type) {
+      case 'init':
+        handler = require(msg.path);
+        break;
+      case 'start':
+        const bundler = await run(
+          process.cwd(),
+          msg.piral,
+          msg.emulator,
+          msg.sourceMaps,
+          msg.contentHash,
+          msg.minify,
+          msg.externals,
+          msg.publicUrl,
+          msg.outFile,
+          msg.outDir,
+          msg.entryFiles,
+          msg.logLevel,
+          msg,
+        );
+        const result = await bundler.bundle();
+
+        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-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,23 +6,37 @@ import {
   callPiralDebug,
   callDebugPiralFromMonoRepo,
 } from './bundler';
+import { callDynamic, callStatic } from './build/bundler-calls';
 import * as common from './common';
 
-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,
       });
     }
@@ -60,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({
@@ -72,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({
@@ -101,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({
@@ -113,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({
@@ -131,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({
@@ -149,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({
@@ -167,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', () => {