rebuiltron 6.0.1 → 6.0.3

package/configurations/base.js

@@ -13,7 +13,6 @@ const { srcAlias } = require(paths.appConfig);
 
 
 module.exports = {
-	mode: isEnvProduction ? "production" : "development",
 	stats: "errors-warnings",
 	bail: isEnvProduction,
 	output: {
@@ -69,9 +68,7 @@ module.exports = {
 		strictExportPresence: true
 	},
 	plugins: [
-		...emptyOr(isEnvDevelopment, [
-			new CaseSensitivePathsPlugin() // Detects case errors in import paths
-		]),
+		...emptyOr(isEnvDevelopment, [new CaseSensitivePathsPlugin()]), // Detects case errors in import paths
 		new ModuleNotFoundPlugin(paths.appPath) // Gives some necessary context to module not found errors
 	],
 	performance: false // Performance processing is already handled via `FileSizeReporter`

package/configurations/main.js

@@ -9,6 +9,7 @@ const { main } = require(paths.appConfig);
 
 module.exports = {
 	...baseConfig,
+	mode: "production",
 	target: "electron-main",
 	entry: {
 		[rebuiltronConfig.buildFileNames.main]: main

package/configurations/preloads.js

@@ -11,6 +11,7 @@ const { preloads } = require(paths.appConfig);
 
 module.exports = {
 	...baseConfig,
+	mode: "production",
 	target: "electron-preload",
 	entry: mapKeys(preloads, (_value, entryName) => (
 		`${rebuiltronConfig.buildFileNames.preload}.${entryName}`
@@ -21,10 +22,8 @@ module.exports = {
 	},
 	module: {
 		...baseConfig.module,
-		rules: [
-			{
-				oneOf: javascriptLoaders
-			}
-		]
+		rules: [{
+			oneOf: javascriptLoaders
+		}]
 	}
 };

package/configurations/renderers.js

@@ -23,6 +23,7 @@ const { renderers } = require(paths.appConfig);
 
 module.exports = {
 	...baseConfig,
+	mode: isEnvProduction ? "production" : "development",
 	target: "browserslist",
 	devtool: shouldUseSourceMap && (isEnvProduction ? "source-map" : "cheap-module-source-map"),
 	entry: renderers,

package/helpers/constants.js

@@ -0,0 +1,16 @@
+const COMPILATION_ASSETS = Object.freeze({
+	PRELOAD: "Preload",
+	MAIN: "Main",
+	RENDERER: "Renderer"
+});
+
+const COMPILATION_STATES = Object.freeze({
+	PENDING: "pending",
+	FATAL_ERROR: "fatalError",
+	ERROR: "error",
+	WARNING: "warning",
+	SUCCESS: "success"
+});
+
+
+module.exports = { COMPILATION_ASSETS, COMPILATION_STATES };

package/helpers/utils.js

@@ -1,14 +1,25 @@
+/* eslint-disable jsdoc/valid-types, jsdoc/match-description */
+
 const path = require("path");
 const fs = require("fs");
 
 const { isArray } = require("lodash");
+const { bold, red, green, yellow } = require("chalk");
 
-const log = require("./logger");
 const spinnies = require("./spinnies");
+const { COMPILATION_STATES } = require("./constants");
 
 
-const _appDirectory = fs.realpathSync(process.cwd());
+/**
+ * @import { Stats } from "webpack"
+ * @import { COMPILATION_ASSETS } from "./constants"
+ */
 
+/**
+ * Path of the app directory.
+ */
+
+const _appDirectory = fs.realpathSync(process.cwd());
 
 /**
  * Resolves a path relative to the app directory.
@@ -19,15 +30,15 @@ const _appDirectory = fs.realpathSync(process.cwd());
 const resolveApp = (relativePath) => path.resolve(_appDirectory, relativePath);
 
 /**
- * Logs error message and stack (if available) and exit the running process.
- * @param {(Error|import("./logger").LogMessage)} error - Error to log
+ * Logs error message (if provided) and exits the running process.
+ * @param {Error} [error] - Error to log
  */
 
 const exitProcessWithError = (error) => {
 	spinnies.stopAll("fail");
 
-	log.error(error?.message || error);
-	if (error.stack) log.info(error.stack);
+	if (!error) return;
+	console.log(red(`\n${error?.message || error}\n`));
 
 	process.exit(1);
 };
@@ -35,8 +46,8 @@ const exitProcessWithError = (error) => {
 /**
  * Returns the given value when the condition is truthy, otherwise an empty element of the same type.
  * @param {any} condition - Condition determining if the value should be returned
- * @param {(object|Array)} value - Value to return
- * @returns {(object|Array)} Value or empty element
+ * @param {(object | Array)} value - Value to return
+ * @returns {(object | Array)} Value or empty element
  */
 
 const emptyOr = (condition, value) => {
@@ -44,5 +55,70 @@ const emptyOr = (condition, value) => {
 	return condition ? value : empty;
 };
 
+/**
+ * Clears the console.
+ */
+
+const clearConsole = () => {
+	process.stdout.write(
+		process.platform === "win32" ? "\x1B[2J\x1B[0f" : "\x1B[2J\x1B[3J\x1B[H"
+	);
+};
+
+/**
+ * Logs stats.
+ * @param {Stats} stats - Stats to log
+ */
+
+const logStats = (stats) => {
+	console.log();
+
+	console.log(stats.toString({
+		colors: true,
+		all: false,
+		warnings: true,
+		errors: true,
+		errorDetails: false
+	}));
+};
+
+/**
+ * @typedef CompilationData
+ * @property {COMPILATION_ASSETS[keyof COMPILATION_ASSETS]} [asset] - Type of the compiled asset
+ * @property {COMPILATION_STATES[keyof COMPILATION_STATES]} state - Compilation state
+ * @property {Stats} [stats] - Compilation stats
+ */
+
+/**
+ * Constructs the text to display for the given compilation state.
+ * @param {CompilationData} data - Compilation data
+ * @returns {string} Compilation text
+ */
+
+const getCompilationText = ({ asset, state, stats }) => {
+	let prefix = asset ? bold(`${asset}: `) : "";
+
+	if (state === COMPILATION_STATES.PENDING) return prefix + `${asset ? "c" : "C"}ompiling...`;
+	if (state === COMPILATION_STATES.FATAL_ERROR) return prefix + bold(`${asset ? "f" : "F"}ailed`) + " to compile";
+
+	prefix += `${asset ? "c" : "C"}ompiled `;
+
+	if (state === COMPILATION_STATES.SUCCESS) return prefix + green(bold("successfully"));
+
+	const isError = state === COMPILATION_STATES.ERROR;
+
+	const count = stats.toJson()[isError ? "errorsCount" : "warningsCount"];
+	const color = isError ? red : yellow;
+
+	return prefix + "with " + bold(color(`${count} ${state}${count > 1 ? "s" : ""}`));
+};
+
 
-module.exports = { resolveApp, exitProcessWithError, emptyOr };
+module.exports = {
+	resolveApp,
+	exitProcessWithError,
+	emptyOr,
+	logStats,
+	clearConsole,
+	getCompilationText
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rebuiltron",
-  "version": "6.0.1",
+  "version": "6.0.3",
   "author": "Arkellys",
   "license": "MIT",
   "bin": {

package/scripts/build.js

@@ -2,6 +2,7 @@ process.env.BABEL_ENV = "production";
 process.env.NODE_ENV = "production";
 
 
+const fsExtra = require("fs-extra");
 const { measureFileSizesBeforeBuild, printFileSizesAfterBuild } = require("react-dev-utils/FileSizeReporter");
 
 const buildApp = require("../tasks/buildApp");
@@ -16,8 +17,13 @@ const WARN_AFTER_BUNDLE_GZIP_SIZE = 512 * 1024;
 const WARN_AFTER_CHUNK_GZIP_SIZE = 1024 * 1024;
 
 checkSetup
-	.then(() => measureFileSizesBeforeBuild(paths.appBuild))
-	.then((previousFileSizes) => buildApp(previousFileSizes))
+	.then(() => (
+		measureFileSizesBeforeBuild(paths.appBuild)
+	))
+	.then((previousFileSizes) => {
+		fsExtra.emptyDirSync(paths.appBuild);
+		return buildApp(previousFileSizes);
+	})
 	.then(({ stats, previousFileSizes }) => {
 		console.log("\nFile sizes after gzip:\n");
 

package/scripts/start.js

@@ -2,14 +2,12 @@ process.env.BABEL_ENV = "development";
 process.env.NODE_ENV = "development";
 
 
-const clearConsole = require("react-dev-utils/clearConsole");
-
 const checkSetup = require("../tasks/checkSetup");
 const startDevServer = require("../tasks/startDevServer");
 const compileMain = require("../tasks/compileMain");
 const watchPreloads = require("../tasks/watchPreloads");
 const startElectron = require("../tasks/startElectron");
-const { exitProcessWithError } = require("../helpers/utils");
+const { exitProcessWithError, clearConsole } = require("../helpers/utils");
 
 
 process.on("unhandledRejection", exitProcessWithError);

package/tasks/buildApp.js

@@ -1,13 +1,9 @@
-const fsExtra = require("fs-extra");
 const webpack = require("webpack");
-const clearConsole = require("react-dev-utils/clearConsole");
-const formatWebpackMessages = require("react-dev-utils/formatWebpackMessages");
-const { bold, green, yellow } = require("chalk");
 
-const paths = require("../helpers/paths");
 const webpackConfig = require("../webpack.config");
 const spinnies = require("../helpers/spinnies");
-const log = require("../helpers/logger");
+const { logStats, getCompilationText, clearConsole } = require("../helpers/utils");
+const { COMPILATION_STATES } = require("../helpers/constants");
 
 
 /**
@@ -16,50 +12,50 @@ const log = require("../helpers/logger");
  * @returns {Promise<{ stats: webpack.Stats | undefined, previousFileSizes: any }>} Result of the build
  */
 
-module.exports = (previousFileSizes) => {
-	fsExtra.emptyDirSync(paths.appBuild);
-	const compiler = webpack(webpackConfig.production);
+module.exports = (previousFileSizes) => new Promise((resolve, reject) => {
+	clearConsole();
+	spinnies.add("build", { text: "Creating the production build" });
 
-	return new Promise((resolve, reject) => {
+	webpack(webpackConfig.production, (error, stats) => {
 		clearConsole();
-		spinnies.add("build", { text: "Creating the production build" });
-
-		compiler.run((error, stats) => {
-			if (!error) {
-				return resolve({
-					stats,
-					previousFileSizes
-				});
-			}
 
+		if (error || stats.hasErrors()) {
 			spinnies.fail("build", {
-				text: "Failed to compile"
+				text: getCompilationText({
+					state: COMPILATION_STATES.FATAL_ERROR
+				})
 			});
 
-			reject(error);
-		});
-
-		compiler.hooks.done.tap("done", (stats) => {
-			clearConsole();
-
-			const statsData = stats.toJson({ all: false, warnings: true, errors: true });
-			const { errors, warnings } = formatWebpackMessages(statsData);
+			if (stats) logStats(stats);
+			return reject(error);
+		}
+
+		if (stats.hasWarnings()) {
+			spinnies.update("build", {
+				text: getCompilationText({
+					state: COMPILATION_STATES.WARNING
+				}),
+				status: "stopped",
+				color: "white"
+			});
 
-			if (stats.hasErrors()) throw new Error(errors);
+			logStats(stats);
 
-			if (stats.hasWarnings()) {
-				spinnies.update("build", {
-					text: `Compiled ${yellow(bold("with warnings"))}`,
-					status: "stopped",
-					color: "white"
-				});
+			return resolve({
+				stats,
+				previousFileSizes
+			});
+		}
 
-				return log.warning(warnings.join("\n\n"));
-			}
+		spinnies.succeed("build", {
+			text: getCompilationText({
+				state: COMPILATION_STATES.SUCCESS
+			})
+		});
 
-			spinnies.succeed("build", {
-				text: `Compiled ${green(bold("successfully"))}`
-			});
+		return resolve({
+			stats,
+			previousFileSizes
 		});
 	});
-};
+});

package/tasks/compileMain.js

@@ -1,9 +1,9 @@
 const webpack = require("webpack");
-const { bold, green } = require("chalk");
-const formatWebpackMessages = require("react-dev-utils/formatWebpackMessages");
 
 const webpackConfig = require("../webpack.config");
 const spinnies = require("../helpers/spinnies");
+const { getCompilationText, logStats } = require("../helpers/utils");
+const { COMPILATION_ASSETS, COMPILATION_STATES } = require("../helpers/constants");
 
 
 /**
@@ -11,31 +11,51 @@ const spinnies = require("../helpers/spinnies");
  * @returns {Promise<void>} Promise resolving when compilation is successful
  */
 
-module.exports = () => {
-	const mainCompiler = webpack(webpackConfig.development.main);
+module.exports = () => new Promise((resolve, reject) => {
+	const asset = COMPILATION_ASSETS.MAIN;
 
-	return new Promise((resolve, reject) => {
-		spinnies.add("compile-main", { text: "Compiling main file..." });
-
-		mainCompiler.run((error) => {
-			if (!error) return resolve();
+	spinnies.add("compile-main", {
+		text: getCompilationText({
+			asset,
+			state: COMPILATION_STATES.PENDING
+		})
+	});
 
+	webpack(webpackConfig.development.main, (error, stats) => {
+		if (error || stats.hasErrors()) {
 			spinnies.fail("compile-main", {
-				text: "Failed to compile main file"
+				text: getCompilationText({
+					asset,
+					state: COMPILATION_STATES.FATAL_ERROR
+				})
 			});
 
-			reject(error);
-		});
-
-		mainCompiler.hooks.done.tap("done", (stats) => {
-			const statsData = stats.toJson({ all: false, warnings: true, errors: true });
-			const { errors } = formatWebpackMessages(statsData);
+			if (stats) logStats(stats);
+			return reject(error);
+		}
+
+		if (stats.hasWarnings()) {
+			spinnies.update("compile-main", {
+				text: getCompilationText({
+					asset,
+					state: COMPILATION_STATES.WARNING,
+					stats
+				}),
+				status: "stopped",
+				color: "white"
+			});
 
-			if (stats.hasErrors()) throw new Error(errors);
+			logStats(stats);
+			return resolve();
+		}
 
-			spinnies.succeed("compile-main", {
-				text: `Main file compiled ${green(bold("successfully"))}`
-			});
+		spinnies.succeed("compile-main", {
+			text: getCompilationText({
+				asset,
+				state: COMPILATION_STATES.SUCCESS
+			})
 		});
+
+		return resolve();
 	});
-};
+});

package/tasks/startDevServer.js

@@ -1,11 +1,12 @@
 const webpack = require("webpack");
 const WebpackDevServer = require("webpack-dev-server");
-const clearConsole = require("react-dev-utils/clearConsole");
 const { bold } = require("chalk");
 
 const webpackConfig = require("../webpack.config");
 const devServerConfig = require("../webpackDevServer.config");
 const spinnies = require("../helpers/spinnies");
+const { getCompilationText, logStats, clearConsole } = require("../helpers/utils");
+const { COMPILATION_ASSETS, COMPILATION_STATES } = require("../helpers/constants");
 
 /**
  * Starts the development server.
@@ -18,28 +19,66 @@ module.exports = (port) => (
 		let devServer;
 		let isFirstRun = true;
 
-		const rendererCompiler = webpack(webpackConfig.development.renderers);
+		const asset = COMPILATION_ASSETS.RENDERER;
+		const compiler = webpack(webpackConfig.development.renderers);
 
 		spinnies.add("devServer", { text: "Starting the development server" });
 
-		rendererCompiler.hooks.invalid.tap("invalid", () => {
-			clearConsole();
-			spinnies.add("compile", { text: "Compiling..." });
+		compiler.hooks.compile.tap("compile", () => {
+			if (!isFirstRun) clearConsole();
+
+			spinnies.add("compile", {
+				text: getCompilationText({
+					asset,
+					state: COMPILATION_STATES.PENDING
+				})
+			});
 		});
 
-		rendererCompiler.hooks.done.tap("done", () => {
+		compiler.hooks.done.tap("done", (stats) => {
 			if (isFirstRun) {
 				isFirstRun = false;
 
 				spinnies.succeed("devServer", { text: `Development server running on port ${bold(port)}` });
-				return resolve(devServer);
+				resolve(devServer);
+			}
+
+			if (stats.hasErrors()) {
+				spinnies.fail("compile", {
+					text: getCompilationText({
+						asset,
+						state: COMPILATION_STATES.ERROR,
+						stats
+					}),
+					failColor: "white"
+				});
+
+				return logStats(stats);
+			}
+
+			if (stats.hasWarnings()) {
+				spinnies.update("compile", {
+					text: getCompilationText({
+						asset,
+						state: COMPILATION_STATES.WARNING,
+						stats
+					}),
+					status: "stopped",
+					color: "white"
+				});
+
+				return logStats(stats);
 			}
 
-			clearConsole();
-			spinnies.remove("compile");
+			spinnies.succeed("compile", {
+				text: getCompilationText({
+					asset,
+					state: COMPILATION_STATES.SUCCESS
+				})
+			});
 		});
 
-		devServer = new WebpackDevServer({ ...devServerConfig, port }, rendererCompiler);
+		devServer = new WebpackDevServer({ ...devServerConfig, port }, compiler);
 		await devServer.start();
 	})
 );

package/tasks/startElectron.js

@@ -2,17 +2,20 @@ const { spawn } = require("child_process");
 const path = require("path");
 const fs = require("fs");
 
+const { bold } = require("chalk");
+
 const spinnies = require("../helpers/spinnies");
 
 
 /**
  * Starts Electron.
  * @param {number} port - Port on which the renderer is served
+ * @returns {Promise<void>} Promise resolving when compilation is successful
  */
 
 module.exports = (port) => (
 	new Promise((resolve, reject) => {
-		spinnies.add("electron", { text: "Starting Electron" });
+		spinnies.add("electron", { text: `Starting ${bold("Electron")}` });
 
 		try {
 			const electronPath = require.resolve("electron");
@@ -29,11 +32,11 @@ module.exports = (port) => (
 				}
 			}).on("close", process.exit);
 
-			spinnies.succeed("electron", { text: "Electron started" });
+			spinnies.succeed("electron", { text: `${bold("Electron")} started` });
 			resolve();
 
 		} catch (error) {
-			spinnies.fail("electron", { text: "Failed to start Electron" });
+			spinnies.fail("electron", { text: `${bold("Failed")} to start Electron` });
 			reject(error);
 		}
 	})

package/tasks/watchPreloads.js

@@ -1,11 +1,9 @@
 const webpack = require("webpack");
-const { red, bold, green, yellow } = require("chalk");
-const formatWebpackMessages = require("react-dev-utils/formatWebpackMessages");
-const clearConsole = require("react-dev-utils/clearConsole");
 
 const webpackConfig = require("../webpack.config");
 const spinnies = require("../helpers/spinnies");
-const log = require("../helpers/logger");
+const { logStats, getCompilationText, clearConsole } = require("../helpers/utils");
+const { COMPILATION_ASSETS, COMPILATION_STATES } = require("../helpers/constants");
 
 
 /**
@@ -13,61 +11,72 @@ const log = require("../helpers/logger");
  * @returns {Promise<void>} Promise resolving when compilation is successful
  */
 
-module.exports = () => {
-	const preloadCompiler = webpack(webpackConfig.development.preloads);
+module.exports = () => new Promise((resolve, reject) => {
+	let isFirstWatch = true;
 
-	return new Promise((resolve, reject) => {
-		let isFirstWatch = true;
+	const asset = COMPILATION_ASSETS.PRELOAD;
+	const compiler = webpack(webpackConfig.development.preloads);
 
-		preloadCompiler.watch({}, (error) => {
-			if (!isFirstWatch) return;
-			isFirstWatch = false;
+	compiler.hooks.compile.tap("compile", () => {
+		if (!isFirstWatch) clearConsole();
 
-			if (!error) return resolve();
+		spinnies.add("watch", {
+			text: getCompilationText({
+				asset,
+				state: COMPILATION_STATES.PENDING
+			})
+		});
+	});
 
+	compiler.watch({}, (error, stats) => {
+		if (error) {
 			spinnies.fail("watch", {
-				text: "Failed to compile preload file(s)"
+				text: getCompilationText({
+					asset,
+					state: COMPILATION_STATES.FATAL_ERROR
+				})
 			});
 
-			reject(error);
-		});
+			return reject(error);
+		}
 
-		preloadCompiler.hooks.compile.tap("compile", () => {
-			if (!isFirstWatch) clearConsole();
+		if (isFirstWatch) {
+			isFirstWatch = false;
+			resolve();
+		}
 
-			spinnies.add("watch", {
-				text: "Compiling preload file(s)..."
+		if (stats.hasErrors()) {
+			spinnies.fail("watch", {
+				text: getCompilationText({
+					asset,
+					state: COMPILATION_STATES.ERROR,
+					stats
+				}),
+				failColor: "white"
 			});
-		});
 
-		preloadCompiler.hooks.done.tap("done", (stats) => {
-			const statsData = stats.toJson({ all: false, warnings: true, errors: true });
-			const { errors, warnings } = formatWebpackMessages(statsData);
-
-			if (stats.hasErrors()) {
-				if (isFirstWatch) throw new Error(errors); // Stops the process
-
-				spinnies.fail("watch", {
-					text: `Preload file(s) compiled ${red(bold("with errors"))}`,
-					failColor: "white"
-				});
-
-				return log.error(errors.join("\n\n"));
-			}
-
-			if (stats.hasWarnings()) {
-				spinnies.update("watch", {
-					text: `Preload file(s) compiled ${yellow(bold("with warnings"))}`,
-					status: "stopped",
-					color: "white"
-				});
+			return logStats(stats);
+		}
+
+		if (stats.hasWarnings()) {
+			spinnies.update("watch", {
+				text: getCompilationText({
+					asset,
+					state: COMPILATION_STATES.WARNING,
+					stats
+				}),
+				status: "stopped",
+				color: "white"
+			});
 
-				return log.warning(warnings.join("\n\n"));
-			}
+			return logStats(stats);
+		}
 
-			spinnies.succeed("watch", {
-				text: `Preload file(s) compiled ${green(bold("successfully"))}`
-			});
+		spinnies.succeed("watch", {
+			text: getCompilationText({
+				asset,
+				state: COMPILATION_STATES.SUCCESS
+			})
 		});
 	});
-};
+});

package/webpackDevServer.config.js

@@ -15,11 +15,15 @@ module.exports = {
 		}
 	},
 	client: {
+		progress: true,
 		overlay: {
 			errors: true,
 			warnings: false
 		}
 	},
+	devMiddleware: {
+		stats: "none" // Already handled manually
+	},
 	historyApiFallback: {
 		disableDotRule: true, // Supports route with dots
 		index: paths.basePath

package/helpers/logger.js

@@ -1,55 +0,0 @@
-const { red, green, yellow, black } = require("chalk");
-const { isString } = require("lodash");
-
-
-/**
- * @typedef {(string|string[])} LogMessage
- */
-
-/**
- * Formats a message into a single string.
- * @param {LogMessage} message - Message to format
- * @returns {string} Formatted message
- */
-
-const _formatMessage = (message) => {
-	if (isString(message)) return message;
-	return message.join("\n");
-};
-
-
-/**
- * Logs a message in red.
- * @param {LogMessage} message - Message to log
- */
-
-const logError = (message) => console.log(red(`\n${_formatMessage(message)}\n`));
-
-/**
- * Logs a message in green.
- * @param {LogMessage} message - Message to log
- */
-
-const logSuccess = (message) => console.log(green(`\n${_formatMessage(message)}\n`));
-
-/**
- * Logs a message in yellow.
- * @param {LogMessage} message - Message to log
- */
-
-const logWarning = (message) => console.log(yellow(`\n${_formatMessage(message)}\n`));
-
-/**
- * Logs a message in black.
- * @param {string} message - Message to log
- */
-
-const logInfo = (message) => console.log(black(`${message}\n`));
-
-
-module.exports = {
-	error: logError,
-	success: logSuccess,
-	warning: logWarning,
-	info: logInfo
-};