piral-cli 0.15.0-beta.4696 → 0.15.0-beta.4708

package/src/common/index.ts

@@ -13,6 +13,8 @@ export * from './http';
 export * from './importmap';
 export * from './info';
 export * from './injectors';
+export * from './inspect';
+export * from './interactive';
 export * from './io';
 export * from './language';
 export * from './log';

package/src/common/injectors.ts

@@ -1,7 +1,7 @@
-import chalk from 'chalk';
 import { resolve } from 'path';
 import { liveIcon, settingsIcon } from './emoji';
 import { logInfo, log, logReset } from './log';
+import { chalk } from '../external';
 import { Bundler } from '../types';
 
 export function notifyServerOnline(bundlers: Array<Bundler>, path: string, api: string | false) {

package/src/common/interactive.test.ts

@@ -6,6 +6,9 @@ jest.mock('../external', () => ({
   rc(_, cfg) {
     return cfg;
   },
+  ora() {
+    return {};
+  },
   inquirer: {
     prompt: (...any) => {
       return Promise.resolve({ q: answer });

package/src/common/log.ts

@@ -1,111 +1,79 @@
 import * as messages from '../messages';
-import { join } from 'path';
 import { format } from 'util';
-import { createWriteStream } from 'fs';
-import { isWindows } from './info';
-import { stripAnsi } from '../external';
+import { ora } from '../external';
 import { LogLevels, QuickMessage } from '../types';
 
 type Messages = typeof messages;
 type MessageTypes = keyof Messages;
 let currentProgress: string = undefined;
-
-const logger = (() => {
-  try {
-    const logger = require('@parcel/logger');
-
-    // check to see if this is really right
-    if (typeof logger.verbose === 'function') {
-      return logger;
-    }
-  } catch {}
-
-  return require('../external').logger;
-})();
-
-// unfortunately, Parcel's support for verbose logging on Windows is broken
-if (isWindows) {
-  logger.verbose = function (message: string) {
-    if (this.logLevel < 4) {
-      return;
-    }
-
-    const currDate = new Date();
-    message = `[${currDate.toLocaleTimeString()}]: ${message}`;
-
-    if (this.logLevel > 4) {
-      if (!this.logFile) {
-        // the critical line is the filename; it must not contain colons!
-        const timestamp = currDate.toISOString().replace(/:/g, '');
-        const fileName = `parcel-debug-${timestamp}.log`;
-        this.logFile = createWriteStream(join(process.cwd(), fileName));
-      }
-
-      this.logFile.write(stripAnsi.default(message) + '\n');
-    }
-
-    this._log(message);
-  };
-}
+let logLevel = LogLevels.info;
+let instance = ora();
 
 export function getLogLevel(): LogLevels {
-  return logger.logLevel;
+  return logLevel;
 }
 
-export function setLogLevel(logLevel: LogLevels) {
-  logger.setOptions({ logLevel });
+export function setLogLevel(value: LogLevels) {
+  logLevel = value;
 }
 
 export function logInfo(message: string, ...args: Array<string | number | boolean>) {
   const msg = format(message, ...args);
-  logger.log(msg);
+  instance.info(msg);
   return msg;
 }
 
 export function logDebug(message: string, ...args: Array<string | number | boolean>) {
   const msg = format(message, ...args);
-  logger.verbose(msg);
+
+  if (logLevel >= LogLevels.debug) {
+    instance.info(msg);
+  }
+
   return msg;
 }
 
 export function logVerbose(message: string, ...args: Array<string | number | boolean>) {
   const msg = format(message, ...args);
-  logger.logLevel > 3 && logger.log(msg);
+
+  if (logLevel >= LogLevels.verbose) {
+    instance.info(msg);
+  }
+
   return msg;
 }
 
 export function logDone(message: string, ...args: Array<string | number | boolean>) {
   const msg = format(message, ...args);
-  logger.success(msg);
+  instance.succeed(msg);
   return msg;
 }
 
 export function logWarn(message: string, ...args: Array<string | number | boolean>) {
   const msg = format(message, ...args);
-  logger.warn(msg);
+  instance.warn(msg);
   return msg;
 }
 
 export function logFail(message: string, ...args: Array<string | number | boolean>) {
   const msg = format(message, ...args);
-  logger.error(msg);
+  instance.fail(msg);
   return msg;
 }
 
 export function progress(message: string, ...args: Array<string | number | boolean>) {
   currentProgress = format(message, ...args)
-  logger.progress(currentProgress);
+  instance.start(message);
 }
 
 export function logReset() {
-  logger.lines = 0;
-  logger.stopSpinner();
+  instance.stop();
 }
 
 export function logSuspend() {
   logReset();
 
-  return () => logger.progress(currentProgress);
+  return () => instance.start(currentProgress);
 }
 
 export function fail<T extends MessageTypes>(type: T, ...args: Parameters<Messages[T]>): never {

package/src/common/npm.test.ts

@@ -28,13 +28,8 @@ jest.mock('child_process');
 
 jest.mock('../external', () => ({
   rc() {},
-  logger: {
-    stopSpinner() {},
-    verbose() {},
-    info() {},
-    error() {},
-    log() {},
-    setOptions() {},
+  ora() {
+    return {};
   },
 }));
 

package/src/common/port.test.ts

@@ -4,7 +4,10 @@ const defaultPort = 12345;
 const error = Error('RangeError: Port should be >= 0 and < 65536.');
 
 jest.mock('../external', () => ({
-  getPort: (options: any) => {
+  ora() {
+    return {};
+  },
+  getPort(options: any) {
     if (options == undefined) {
       return Promise.resolve(defaultPort);
     } else if (options && options.port && options.port > 65536) {

package/src/common/rules.test.ts

@@ -1,5 +1,5 @@
 import { ruleSummary, runRules } from './rules';
-import chalk from 'chalk';
+import { chalk } from '../external';
 
 const rule = {
   run: jest.fn(),
@@ -13,9 +13,9 @@ describe('Rules Module', () => {
     };
     expect(runException).toThrow(Error('[0080] Validation failed. Found 1 error(s).'));
 
-    let consoleSpy = jest.spyOn(console, 'log');
+    let consoleSpy = jest.spyOn(process.stderr, 'write');
     ruleSummary([], []);
-    expect(consoleSpy).toHaveBeenCalledWith(`✨  ${chalk.green.bold('Validation successful. No errors or warnings.')}`);
+    expect(consoleSpy).toHaveBeenLastCalledWith(`${chalk.green('✔')} Validation successful. No errors or warnings.\n`);
 
     jest.clearAllMocks();
     ruleSummary([], ['Warning!']);

package/src/external/index.test.ts

@@ -1,4 +1,4 @@
-import * as externals from './index';
+import * as externals from '../external';
 
 describe('Externals module', () => {
   it('exports the FormData class', () => {
@@ -27,7 +27,7 @@ describe('Externals module', () => {
   });
 
   it('exports the logger module', () => {
-    const logger = externals.logger;
+    const logger = externals.ora;
     expect(logger).not.toBeUndefined();
   });
 

package/src/external/index.ts

@@ -1,5 +1,3 @@
-import logger = require('@parcel/logger');
-import stripAnsi = require('strip-ansi');
 import inquirer = require('inquirer');
 import jju = require('jju');
 import glob = require('glob');
@@ -10,5 +8,10 @@ import axios = require('axios');
 import mime = require('mime');
 import getPort = require('get-port');
 import open = require('open');
+import chalk = require('chalk');
 
-export { logger, inquirer, glob, tar, FormData, rc, axios, mime, stripAnsi, getPort, open, jju };
+import isInteractive from 'is-interactive';
+import ora from 'ora';
+import { getModulePath } from './resolve';
+
+export { chalk, inquirer, isInteractive, ora, glob, tar, FormData, rc, axios, mime, getPort, open, jju, getModulePath };

package/src/external/resolve.ts

@@ -0,0 +1,28 @@
+import * as fs from 'graceful-fs';
+import { ResolverFactory, CachedInputFileSystem } from 'enhanced-resolve';
+
+const nodeFileSystem = new CachedInputFileSystem(fs, 4000);
+
+const nodeContext = {
+  environments: ['node+es3+es5+process+native'],
+};
+
+const enhancedResolve = ResolverFactory.createResolver({
+  aliasFields: ['browser'],
+  conditionNames: ['import', 'module', 'webpack', 'development', 'browser'],
+  extensions: ['.js', '.jsx', '.mjs', '.ts', '.tsx', '.json'],
+  exportsFields: ['exports'],
+  importsFields: ['imports'],
+  mainFields: ['browser', 'module', 'main'],
+  fileSystem: nodeFileSystem,
+});
+
+export function getModulePath(root: string, moduleName: string) {
+  const res = enhancedResolve.resolveSync(nodeContext, root, moduleName);
+
+  if (!res) {
+    throw new Error(`Could not find module "${moduleName}".`);
+  }
+
+  return res;
+}

package/src/messages.ts

@@ -2598,6 +2598,39 @@ export function bundlerUnspecified_0175(available: Array<string>): QuickMessage
   ];
 }
 
+/**
+ * @kind Warning
+ *
+ * @summary
+ * No bundler has been installed yet.
+ *
+ * @abstract
+ * Piral allows you to set up your own tooling for building and debugging. This
+ * is a powerful concept. By default, the Webpack v5 bundler is used.
+ * Alternatives include Parcel and Rollup.
+ *
+ * In case no bundler is yet installed the Piral CLI will automatically install
+ * the default bundler. However, you should consider installing a bundler of your
+ * choice (even if this could also be the default bundler) explicitly.
+ *
+ * @see
+ * - [Pluggable bundlers](https://docs.piral.io/reference/documentation/bundlers)
+ *
+ * @example
+ * Use the following command to install esbuild as a bundler with the npm client:
+ *
+ * ```sh
+ * npm i piral-cli-esbuild --save-dev
+ * ```
+ */
+export function bundlerNotInstalled_0176(): QuickMessage {
+  return [
+    LogLevels.warning,
+    '0176',
+    `Installing default bundler since no bundler has been found.`,
+  ];
+}
+
 /**
  * @kind Warning
  *

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;