piral-cli 1.0.0-pre.2217 → 1.0.0

package/src/types/internal.ts

@@ -1,18 +1,18 @@
-import { LogLevels } from './common';
+import type { LogLevels } from './common';
+import type { PiletSchemaVersion } from './public';
 
-export interface PackageData {
-  name: string;
-  version: string;
-  description: string;
-  main: string;
-  author:
-    | string
-    | {
-        name?: string;
-        url?: string;
-        email?: string;
-      };
-  custom?: any;
+/**
+ * Shape of the pilet.json
+ */
+export interface PiletDefinition {
+  schemaVersion?: PiletSchemaVersion;
+  piralInstances?: Record<
+    string,
+    {
+      selected?: boolean;
+      port?: number;
+    }
+  >;
 }
 
 export interface PackageFiles {

package/src/types/public.ts

@@ -1,13 +1,5 @@
 import { Argv, Arguments } from 'yargs';
-import {
-  RuleRunner,
-  PiletRuleContext,
-  PiralRuleContext,
-  Bundler,
-  BundleDetails,
-  LogLevels,
-  ReleaseProvider,
-} from './common';
+import { RuleRunner, PiletRuleContext, PiralRuleContext, LogLevels, SharedDependency, ReleaseProvider } from './common';
 
 export interface ToolCommandRunner<U = {}> {
   (args: Arguments<U>): void | Promise<void>;
@@ -75,25 +67,30 @@ export interface BaseBundleParameters {
 }
 
 export interface DebugPiralParameters extends BaseBundleParameters {
-  piral: string;
+  piralInstances: Array<string>;
   hmr: boolean;
   externals: Array<string>;
   publicUrl: string;
+  outFile: string;
+  outDir: string;
   entryFiles: string;
   logLevel: LogLevels;
 }
 
 export interface WatchPiralParameters extends BaseBundleParameters {
-  piral: string;
+  piralInstances: Array<string>;
   externals: Array<string>;
+  publicUrl: string;
   entryFiles: string;
   logLevel: LogLevels;
 }
 
 export interface BuildPiralParameters extends BaseBundleParameters {
-  piral: string;
+  piralInstances: Array<string>;
   emulator: boolean;
+  standalone: boolean;
   sourceMaps: boolean;
+  watch: boolean;
   contentHash: boolean;
   minify: boolean;
   externals: Array<string>;
@@ -105,21 +102,26 @@ export interface BuildPiralParameters extends BaseBundleParameters {
 }
 
 export interface DebugPiletParameters extends BaseBundleParameters {
-  piral: string;
+  piralInstances: Array<string>;
   hmr: boolean;
   externals: Array<string>;
+  importmap: Array<SharedDependency>;
   targetDir: string;
+  outFile: string;
+  outDir: string;
   entryModule: string;
   logLevel: LogLevels;
   version: PiletSchemaVersion;
 }
 
 export interface BuildPiletParameters extends BaseBundleParameters {
-  piral: string;
+  piralInstances: Array<string>;
   sourceMaps: boolean;
+  watch: boolean;
   contentHash: boolean;
   minify: boolean;
   externals: Array<string>;
+  importmap: Array<SharedDependency>;
   targetDir: string;
   outFile: string;
   outDir: string;
@@ -128,28 +130,85 @@ export interface BuildPiletParameters extends BaseBundleParameters {
   version: PiletSchemaVersion;
 }
 
-export interface WatchPiralBundlerDefinition {
-  run(args: WatchPiralParameters): Promise<Bundler>;
+export interface BundlerPrepareArgs<T> {
+  (args: T): T | Promise<T>;
 }
 
-export interface DebugPiralBundlerDefinition {
+export interface BaseBundlerDefinition<T> {
+  path: string;
+  prepare?: BundlerPrepareArgs<T>;
+}
+
+export interface WatchPiralBundlerDefinition extends BaseBundlerDefinition<WatchPiralParameters> {}
+
+export interface DebugPiralBundlerDefinition extends BaseBundlerDefinition<DebugPiralParameters> {
   flags?: ToolCommandFlagsSetter;
-  run(args: DebugPiralParameters): Promise<Bundler>;
 }
 
-export interface BuildPiralBundlerDefinition {
+export interface BuildPiralBundlerDefinition extends BaseBundlerDefinition<BuildPiralParameters> {
   flags?: ToolCommandFlagsSetter;
-  run(args: BuildPiralParameters): Promise<BundleDetails>;
 }
 
-export interface DebugPiletBundlerDefinition {
+export interface DebugPiletBundlerDefinition extends BaseBundlerDefinition<DebugPiletParameters> {
   flags?: ToolCommandFlagsSetter;
-  run(args: DebugPiletParameters): Promise<Bundler>;
 }
 
-export interface BuildPiletBundlerDefinition {
+export interface BuildPiletBundlerDefinition extends BaseBundlerDefinition<BuildPiletParameters> {
   flags?: ToolCommandFlagsSetter;
-  run(args: BuildPiletParameters): Promise<BundleDetails>;
+}
+
+export interface PiralBuildHandler {
+  create(config: {
+    root: string;
+    entryFiles: string;
+    outDir: string;
+    outFile: string;
+    externals: Array<string>;
+    emulator: boolean;
+    sourceMaps: boolean;
+    contentHash: boolean;
+    minify: boolean;
+    publicUrl: string;
+    hmr: boolean;
+    logLevel: LogLevels;
+    watch: boolean;
+    args: any;
+  }): Promise<BundleHandlerResponse>;
+}
+
+export interface PiletBuildHandler {
+  create(config: {
+    root: string;
+    piralInstances: Array<string>;
+    entryModule: string;
+    targetDir: string;
+    outDir: string;
+    outFile: string;
+    externals: Array<string>;
+    importmap: Array<SharedDependency>;
+    version: PiletSchemaVersion;
+    develop: boolean;
+    sourceMaps: boolean;
+    contentHash: boolean;
+    minify: boolean;
+    logLevel: LogLevels;
+    watch: boolean;
+    args: any;
+  }): Promise<BundleHandlerResponse>;
+}
+
+export interface BundleResult {
+  outDir: string;
+  outFile: string;
+  hash?: string;
+  name?: string;
+  requireRef?: string;
+}
+
+export interface BundleHandlerResponse {
+  onStart(cb: () => void): void;
+  onEnd(cb: (result: BundleResult) => void): void;
+  bundle(): Promise<BundleResult>;
 }
 
 export interface BundlerDefinition {
@@ -160,15 +219,21 @@ export interface BundlerDefinition {
   buildPilet: BuildPiletBundlerDefinition;
 }
 
-export type PiletSchemaVersion = 'none' | 'v0' | 'v1';
+export type PiletSchemaVersion = 'none' | 'v0' | 'v1' | 'v2' | 'v3';
+
+export type SourceLanguage = 'js' | 'ts';
+
+export type PiletPublishScheme = 'none' | 'digest' | 'bearer' | 'basic';
 
 export type PiletPublishSource = 'local' | 'npm' | 'remote';
 
 export type PiralBuildType = 'all' | 'release' | 'emulator' | 'emulator-sources';
 
+export type PiletBuildType = 'default' | 'standalone' | 'manifest';
+
 export type PackageType = 'registry' | 'file' | 'git';
 
-export type NpmClientType = 'npm' | 'yarn' | 'pnpm';
+export type NpmClientType = 'npm' | 'yarn' | 'pnp' | 'pnpm' | 'lerna' | 'rush';
 
 export type Framework = 'piral' | 'piral-core' | 'piral-base';
 
@@ -177,6 +242,7 @@ export interface StandardEnvProps {
   debugPiral?: boolean;
   debugPilet?: boolean;
   root: string;
-  piral?: string;
+  publicPath?: string;
+  piralInstances?: Array<string>;
   dependencies?: Array<string>;
 }

package/lib/external/child.js

@@ -1,144 +0,0 @@
-const {errorUtils} = require('@parcel/utils');
-
-class Child {
-  constructor() {
-    if (!process.send) {
-      throw new Error('Only create Child instances in a worker!');
-    }
-
-    this.module = undefined;
-    this.childId = undefined;
-
-    this.callQueue = [];
-    this.responseQueue = new Map();
-    this.responseId = 0;
-    this.maxConcurrentCalls = 10;
-  }
-
-  messageListener(data) {
-    if (data === 'die') {
-      return this.end();
-    }
-
-    let type = data.type;
-    if (type === 'response') {
-      return this.handleResponse(data);
-    } else if (type === 'request') {
-      return this.handleRequest(data);
-    }
-  }
-
-  async send(data) {
-    process.send(data, err => {
-      if (err && err instanceof Error) {
-        if (err.code === 'ERR_IPC_CHANNEL_CLOSED') {
-          // IPC connection closed
-          // no need to keep the worker running if it can't send or receive data
-          return this.end();
-        }
-      }
-    });
-  }
-
-  childInit(module, childId) {
-    this.module = require(module);
-    this.childId = childId;
-  }
-
-  async handleRequest(data) {
-    let idx = data.idx;
-    let child = data.child;
-    let method = data.method;
-    let args = data.args;
-
-    let result = {idx, child, type: 'response'};
-    try {
-      result.contentType = 'data';
-      if (method === 'childInit') {
-        result.content = this.childInit(...args, child);
-      } else {
-        result.content = await this.module[method](...args);
-      }
-    } catch (e) {
-      result.contentType = 'error';
-      result.content = errorUtils.errorToJson(e);
-    }
-
-    this.send(result);
-  }
-
-  async handleResponse(data) {
-    let idx = data.idx;
-    let contentType = data.contentType;
-    let content = data.content;
-    let call = this.responseQueue.get(idx);
-
-    if (contentType === 'error') {
-      call.reject(errorUtils.jsonToError(content));
-    } else {
-      call.resolve(content);
-    }
-
-    this.responseQueue.delete(idx);
-
-    // Process the next call
-    this.processQueue();
-  }
-
-  // Keep in mind to make sure responses to these calls are JSON.Stringify safe
-  async addCall(request, awaitResponse = true) {
-    let call = request;
-    call.type = 'request';
-    call.child = this.childId;
-    call.awaitResponse = awaitResponse;
-
-    let promise;
-    if (awaitResponse) {
-      promise = new Promise((resolve, reject) => {
-        call.resolve = resolve;
-        call.reject = reject;
-      });
-    }
-
-    this.callQueue.push(call);
-    this.processQueue();
-
-    return promise;
-  }
-
-  async sendRequest(call) {
-    let idx;
-    if (call.awaitResponse) {
-      idx = this.responseId++;
-      this.responseQueue.set(idx, call);
-    }
-    this.send({
-      idx: idx,
-      child: call.child,
-      type: call.type,
-      location: call.location,
-      method: call.method,
-      args: call.args,
-      awaitResponse: call.awaitResponse
-    });
-  }
-
-  async processQueue() {
-    if (!this.callQueue.length) {
-      return;
-    }
-
-    if (this.responseQueue.size < this.maxConcurrentCalls) {
-      this.sendRequest(this.callQueue.shift());
-    }
-  }
-
-  end() {
-    process.exit();
-  }
-}
-
-let child = new Child();
-process.on('message', child.messageListener.bind(child));
-
-module.exports = child;