piral-cli 1.0.0-pre.2296 → 1.0.1-beta.5640

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

@@ -0,0 +1,91 @@
+import { setStandardEnvs } from '../common';
+import type { PiletSchemaVersion, LogLevels, SharedDependency, PiletBuildHandler } from '../types';
+
+let handler: PiletBuildHandler;
+
+function run(
+  root: string,
+  piralInstances: Array<string>,
+  sourceMaps: boolean,
+  watch: 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,
+    piralInstances,
+    root,
+  });
+
+  return handler.create({
+    root,
+    piralInstances,
+    entryModule,
+    targetDir,
+    outDir,
+    outFile,
+    externals,
+    importmap,
+    version,
+    develop: false,
+    sourceMaps,
+    contentHash,
+    minify,
+    logLevel,
+    watch,
+    args,
+  });
+}
+
+process.on('message', async (msg: any) => {
+  try {
+    switch (msg.type) {
+      case 'init':
+        handler = require(msg.path);
+        break;
+      case 'start':
+        const bundler = await run(
+          process.cwd(),
+          msg.piralInstances,
+          msg.sourceMaps,
+          msg.watch,
+          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 && !msg.watch) {
+          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,93 @@
+import { setStandardEnvs } from '../common';
+import type { PiralBuildHandler, LogLevels } from '../types';
+
+let handler: PiralBuildHandler;
+
+function run(
+  root: string,
+  piralInstances: Array<string>,
+  emulator: boolean,
+  standalone: boolean,
+  sourceMaps: boolean,
+  watch: boolean,
+  contentHash: boolean,
+  minify: boolean,
+  externals: Array<string>,
+  publicUrl: string,
+  outFile: string,
+  outDir: string,
+  entryFiles: string,
+  logLevel: LogLevels,
+  args: any,
+) {
+  setStandardEnvs({
+    production: !emulator,
+    root,
+    publicPath: publicUrl,
+    debugPiral: emulator,
+    debugPilet: emulator || standalone,
+    piralInstances,
+    dependencies: externals,
+  });
+
+  return handler.create({
+    root,
+    entryFiles,
+    outFile,
+    outDir,
+    externals,
+    emulator,
+    sourceMaps,
+    contentHash,
+    minify,
+    publicUrl,
+    hmr: false,
+    logLevel,
+    watch,
+    args,
+  });
+}
+
+process.on('message', async (msg: any) => {
+  try {
+    switch (msg.type) {
+      case 'init':
+        handler = require(msg.path);
+        break;
+      case 'start':
+        const bundler = await run(
+          process.cwd(),
+          msg.piralInstances,
+          msg.emulator,
+          msg.standalone,
+          msg.sourceMaps,
+          msg.watch,
+          msg.contentHash,
+          msg.minify,
+          msg.externals,
+          msg.publicUrl,
+          msg.outFile,
+          msg.outDir,
+          msg.entryFiles,
+          msg.logLevel,
+          msg,
+        );
+        const result = await bundler.bundle();
+
+        if (result && !msg.watch) {
+          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,86 @@
+import { resolve } from 'path';
+import { setStandardEnvs } from '../common';
+import type { LogLevels, PiralBuildHandler } from '../types';
+
+let handler: PiralBuildHandler;
+
+function run(
+  root: string,
+  outFile: string,
+  outDir: string,
+  piralInstances: Array<string>,
+  hmr: boolean,
+  externals: Array<string>,
+  publicUrl: string,
+  entryFiles: string,
+  logLevel: LogLevels,
+  args: any,
+) {
+  setStandardEnvs({
+    piralInstances,
+    dependencies: externals,
+    publicPath: publicUrl,
+    production: false,
+    debugPiral: true,
+    debugPilet: true,
+    root,
+  });
+
+  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: any) => {
+  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.piralInstances,
+          true,
+          msg.externals,
+          msg.publicUrl,
+          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-pilet.ts

@@ -0,0 +1,116 @@
+import { setStandardEnvs } from '../common';
+import type {
+  PiletSchemaVersion,
+  LogLevels,
+  SharedDependency,
+  BundleHandlerResponse,
+  PiletBuildHandler,
+} from '../types';
+
+let handler: PiletBuildHandler;
+let bundler: BundleHandlerResponse;
+
+function run(
+  root: string,
+  targetDir: string,
+  outDir: string,
+  outFile: string,
+  piralInstances: Array<string>,
+  externals: Array<string>,
+  importmap: Array<SharedDependency>,
+  entryModule: string,
+  version: PiletSchemaVersion,
+  logLevel: LogLevels,
+  args: any,
+) {
+  setStandardEnvs({
+    production: false,
+    piralInstances,
+    root,
+  });
+
+  return handler.create({
+    root,
+    piralInstances,
+    entryModule,
+    targetDir,
+    outDir,
+    outFile,
+    externals,
+    importmap,
+    version,
+    develop: true,
+    sourceMaps: true,
+    contentHash: true,
+    minify: false,
+    logLevel,
+    watch: true,
+    args,
+  });
+}
+
+process.on('message', async (msg: any) => {
+  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':
+        bundler = await run(
+          root,
+          msg.targetDir,
+          msg.outDir,
+          msg.outFile,
+          msg.piralInstances,
+          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: msg.outDir,
+          });
+        }
+
+        break;
+    }
+  } catch (error) {
+    process.send({
+      type: 'fail',
+      error: error?.message,
+    });
+  }
+});

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

@@ -0,0 +1,105 @@
+import { setStandardEnvs } from '../common';
+import type { BundleHandlerResponse, LogLevels, PiralBuildHandler } from '../types';
+
+let handler: PiralBuildHandler;
+let bundler: BundleHandlerResponse;
+
+function run(
+  root: string,
+  outFile: string,
+  outDir: string,
+  piralInstances: Array<string>,
+  hmr: boolean,
+  externals: Array<string>,
+  publicUrl: string,
+  entryFiles: string,
+  logLevel: LogLevels,
+  args: any,
+) {
+  setStandardEnvs({
+    root,
+    debugPiral: true,
+    dependencies: externals,
+    publicPath: publicUrl,
+    piralInstances,
+  });
+
+  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: any) => {
+  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':
+        bundler = await run(
+          root,
+          msg.outFile,
+          msg.outDir,
+          msg.piralInstances,
+          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: msg.outDir,
+          });
+        }
+
+        break;
+    }
+  } catch (error) {
+    process.send({
+      type: 'fail',
+      error: error?.message,
+    });
+  }
+});