feat: add option to disable stage messages (#356)

* feat: add option to disable stage messages

* build: support optional chaining

* style: lint fix

* test: no stage messages

* test: unname parametrized snapshot

Author: iamogbz

README.md

@@ -53,6 +53,7 @@ module.exports = {
                 buildStart: () => execSync("echo 'hello'"),
                 buildEnd: () => execSync("echo 'bye bye'"),
             },
+            stageMessages: null, // to disable stage messages
         }),
     ],
 };

package.json

@@ -87,6 +87,7 @@
     "devDependencies": {
         "@babel/cli": "^7.8.4",
         "@babel/core": "^7.9.0",
+        "@babel/plugin-proposal-optional-chaining": "^7.9.0",
         "@babel/preset-env": "^7.9.5",
         "@babel/preset-typescript": "^7.9.0",
         "@commitlint/cli": "^8.3.5",

src/constants.ts

@@ -1,30 +1,29 @@
-const enterStageMessage = (m: TemplateStringsArray) =>
-    `\n------${String(m) ? `\n${m}` : ""}`;
+const stageMessage = (m: TemplateStringsArray) => (m ? `\n${String(m)}` : "");
 
-const endStageMessage = (m: TemplateStringsArray) =>
-    `${String(m) ? `${m}\n` : ""}------`;
-
-export const stageMessages: Record<Stage, { enter?: string; exit?: string }> = {
+export const defaultStageMessages: Record<
+    Stage,
+    { enter?: string; exit?: string }
+> = {
     buildEnd: {
-        enter: enterStageMessage`🌇  Build exiting...`,
-        exit: endStageMessage``,
+        enter: stageMessage`🌇 Build exiting 🌇`,
+        exit: stageMessage`🌇 🌇 🌇 🌇 🌇`,
     },
     buildError: {
-        enter: enterStageMessage`🚒  Build failed.`,
+        enter: stageMessage`🚒 Build failed 🚒`,
     },
     buildStart: {
-        enter: enterStageMessage`🌅  Build starting...`,
-        exit: endStageMessage``,
+        enter: stageMessage`🌅 Build starting 🌅`,
+        exit: stageMessage`🌅 🌅 🌅 🌅 🌅`,
     },
     compileEnd: {
-        enter: enterStageMessage`⌛  Code compiled.`,
-        exit: endStageMessage``,
+        enter: stageMessage`⌛ Code compiled ⌛`,
+        exit: stageMessage`⌛ ⌛ ⌛ ⌛ ⌛`,
     },
     compileStart: {
-        enter: enterStageMessage`⏳  Code compiling...`,
-        exit: endStageMessage``,
+        enter: stageMessage`⏳ Code compiling ⏳`,
+        exit: stageMessage`⏳ ⏳ ⏳ ⏳ ⏳`,
     },
     interrupt: {
-        enter: enterStageMessage`🚧  Build interrupted.`,
+        enter: stageMessage`🚧 Build interrupted 🚧`,
     },
 };

src/globals.d.ts

@@ -7,9 +7,11 @@ type Stage =
     | "compileEnd"
     | "compileStart"
     | "interrupt";
-type StageListeners = { [key in Stage]: Listener };
+type StageListeners = Record<Stage, Listener>;
+type StageMessages = Record<Stage, { enter?: string; exit?: string }>;
 
 interface Options {
     name: string;
+    stageMessages?: Partial<StageMessages>;
     listeners: Partial<StageListeners>;
 }

src/index.ts

@@ -1,11 +1,11 @@
 import { Compiler } from "webpack";
 
-import { stageMessages } from "./constants";
+import { logger } from "./logger";
+import { defaultStageMessages } from "./constants";
 
-const log = console.log.bind(console); // eslint-disable-line no-console
 const defaultListeners: Partial<StageListeners> = {
     buildError: (e: Error) => {
-        console.error(e); // eslint-disable-line no-console
+        logger.error(e); // eslint-disable-line no-console
         process.exit(1);
     },
     interrupt: () => {
@@ -20,30 +20,51 @@ export class WebpackCompilerPlugin {
         this.options = this.validate(options);
     }
 
-    private validate(options: Options) {
-        const validOptions: Options = { ...options, listeners: {} };
-        for (const stage of Object.keys(stageMessages) as Stage[]) {
-            const listener = options.listeners[stage];
+    private validate({
+        stageMessages = defaultStageMessages,
+        ...options
+    }: Options) {
+        const validOptions: Options = {
+            ...options,
+            stageMessages,
+        };
+        const listeners = { ...defaultListeners, ...options.listeners };
+        for (const stage of Object.keys(listeners) as Stage[]) {
+            const enterMessage = stageMessages?.[stage]?.enter;
+            const exitMessage = stageMessages?.[stage]?.exit;
+            const listener = listeners[stage];
             const validListener =
                 typeof listener === "function"
                     ? listener
                     : defaultListeners[stage];
             validOptions.listeners[stage] = async (...args) => {
-                log(stageMessages[stage].enter);
+                enterMessage && logger.info(enterMessage);
                 validListener && validListener(...args);
-                log(stageMessages[stage].exit);
+                exitMessage && logger.info(exitMessage);
             };
         }
         return validOptions;
     }
 
     public apply(compiler: Compiler) {
         const { name, listeners } = this.options;
-        compiler.hooks.afterPlugins.tap(name, listeners.buildStart);
-        process.on("exit", listeners.buildEnd);
-        process.on("uncaughtException", listeners.buildError);
-        compiler.hooks.compilation.tap(name, listeners.compileStart);
-        compiler.hooks.done.tap(name, listeners.compileEnd);
-        process.on("SIGINT", listeners.interrupt);
+        if (listeners.buildStart) {
+            compiler.hooks.afterPlugins.tap(name, listeners.buildStart);
+        }
+        if (listeners.buildEnd) {
+            process.on("exit", listeners.buildEnd);
+        }
+        if (listeners.buildError) {
+            process.on("uncaughtException", listeners.buildError);
+        }
+        if (listeners.compileStart) {
+            compiler.hooks.compilation.tap(name, listeners.compileStart);
+        }
+        if (listeners.compileEnd) {
+            compiler.hooks.done.tap(name, listeners.compileEnd);
+        }
+        if (listeners.interrupt) {
+            process.on("SIGINT", listeners.interrupt);
+        }
     }
 }

src/logger.ts

@@ -0,0 +1 @@
+export const logger = console;

tests/__snapshots__/index.test.ts.snap

@@ -8,7 +8,14 @@ Array [
 ]
 `;
 
-exports[`default listeners loads with default buildError listener: console log 1`] = `Array []`;
+exports[`default listeners loads with default buildError listener: console log 1`] = `
+Array [
+  Array [
+    "
+🚒 Build failed 🚒",
+  ],
+]
+`;
 
 exports[`default listeners loads with default buildError listener: process exit 1`] = `
 Array [
@@ -20,7 +27,14 @@ Array [
 
 exports[`default listeners loads with default interrupt listener: console error 1`] = `Array []`;
 
-exports[`default listeners loads with default interrupt listener: console log 1`] = `Array []`;
+exports[`default listeners loads with default interrupt listener: console log 1`] = `
+Array [
+  Array [
+    "
+🚧 Build interrupted 🚧",
+  ],
+]
+`;
 
 exports[`default listeners loads with default interrupt listener: process exit 1`] = `
 Array [
@@ -29,3 +43,48 @@ Array [
   ],
 ]
 `;
+
+exports[`stage messages does not use default state messages buildStart 1`] = `Array []`;
+
+exports[`stage messages does not use default state messages compileEnd 1`] = `Array []`;
+
+exports[`stage messages does not use default state messages compileStart 1`] = `Array []`;
+
+exports[`stage messages uses default state messages buildStart 1`] = `
+Array [
+  Array [
+    "
+🌅 Build starting 🌅",
+  ],
+  Array [
+    "
+🌅 🌅 🌅 🌅 🌅",
+  ],
+]
+`;
+
+exports[`stage messages uses default state messages compileEnd 1`] = `
+Array [
+  Array [
+    "
+⌛ Code compiled ⌛",
+  ],
+  Array [
+    "
+⌛ ⌛ ⌛ ⌛ ⌛",
+  ],
+]
+`;
+
+exports[`stage messages uses default state messages compileStart 1`] = `
+Array [
+  Array [
+    "
+⏳ Code compiling ⏳",
+  ],
+  Array [
+    "
+⏳ ⏳ ⏳ ⏳ ⏳",
+  ],
+]
+`;

tests/index.test.ts

@@ -1,12 +1,14 @@
 import { Compiler } from "webpack";
 import { WebpackCompilerPlugin } from "index";
+import { logger } from "logger";
+import { listeners } from "cluster";
 
 const processExitSpy = jest
     .spyOn(process, "exit")
     .mockImplementation(() => undefined as never);
 
-const consoleLogSpy = jest.spyOn(console, "log");
-const consoleErrorSpy = jest.spyOn(console, "error");
+const consoleLogSpy = jest.spyOn(logger, "info");
+const consoleErrorSpy = jest.spyOn(logger, "error");
 
 const mockCompiler = {
     hooks: {
@@ -16,10 +18,17 @@ const mockCompiler = {
     },
 };
 
-const newPlugin = (listeners: Partial<StageListeners> = {}) => {
+const newPlugin = ({
+    listeners = {},
+    stageMessages,
+}: {
+    listeners?: Partial<StageListeners>;
+    stageMessages?: Partial<StageMessages>;
+}) => {
     const plugin = new WebpackCompilerPlugin({
         name: "webpack-compiler-plugin",
         listeners,
+        stageMessages,
     });
     plugin.apply((mockCompiler as unknown) as Compiler);
     return plugin;
@@ -28,7 +37,7 @@ const newPlugin = (listeners: Partial<StageListeners> = {}) => {
 afterEach(() => {
     jest.clearAllMocks();
     const signals = ["exit", "SIGINT", "uncaughtException"];
-    signals.map(s => process.removeAllListeners(s));
+    signals.map(process.removeAllListeners.bind(process));
 });
 afterAll(jest.restoreAllMocks);
 
@@ -37,7 +46,7 @@ describe("default listeners", () => {
         ["interrupt", ["SIGINT"]],
         ["buildError", ["uncaughtException", new Error("Uncaught Error")]],
     ])("loads with default %s listener", (_, [event, arg]): void => {
-        newPlugin();
+        newPlugin({});
         process.emit(
             event as NodeJS.Signals,
             (arg as unknown) as NodeJS.Signals,
@@ -58,7 +67,7 @@ describe("apply listeners", () => {
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         (stage: Stage, [event, arg]: [NodeJS.Signals, any]) => {
             const mockHandler = jest.fn();
-            newPlugin({ [stage]: mockHandler });
+            newPlugin({ listeners: { [stage]: mockHandler } });
             process.emit(event, arg);
             expect(mockHandler).toHaveBeenCalledTimes(1);
         },
@@ -70,7 +79,36 @@ describe("apply listeners", () => {
         ["compileStart", mockCompiler.hooks.compilation.tap],
     ])("applies handler for stage %s", (stage, tapFn) => {
         const mockHandler = jest.fn();
-        newPlugin({ [stage as Stage]: mockHandler });
+        newPlugin({ listeners: { [stage as Stage]: mockHandler } });
         expect(tapFn).toHaveBeenCalledTimes(1);
+        tapFn.mock.calls[0][1]();
+        expect(mockHandler).toHaveBeenCalledTimes(1);
+    });
+});
+
+describe("stage messages", () => {
+    it.each([
+        ["buildStart", mockCompiler.hooks.afterPlugins.tap],
+        ["compileEnd", mockCompiler.hooks.done.tap],
+        ["compileStart", mockCompiler.hooks.compilation.tap],
+    ])("uses default state messages %s", (stage, tapFn) => {
+        const mockHandler = jest.fn();
+        newPlugin({ listeners: { [stage as Stage]: mockHandler } });
+        tapFn.mock.calls[0][1]();
+        expect(consoleLogSpy.mock.calls).toMatchSnapshot();
+    });
+
+    it.each([
+        ["buildStart", mockCompiler.hooks.afterPlugins.tap],
+        ["compileEnd", mockCompiler.hooks.done.tap],
+        ["compileStart", mockCompiler.hooks.compilation.tap],
+    ])("does not use default state messages %s", (stage, tapFn) => {
+        const mockHandler = jest.fn();
+        newPlugin({
+            listeners: { [stage as Stage]: mockHandler },
+            stageMessages: null,
+        });
+        tapFn.mock.calls[0][1]();
+        expect(consoleLogSpy.mock.calls).toMatchSnapshot();
     });
 });

tsconfig.json

@@ -11,5 +11,5 @@
         "noFallthroughCasesInSwitch": true,
         "noImplicitAny": true
     },
-    "exclude": ["node_modules", "lib"]
+    "exclude": ["node_modules", "lib", "built"]
 }

webpack.config.ts

@@ -15,6 +15,7 @@ const configuration: Configuration = {
                     loader: "babel-loader",
                     options: {
                         presets: ["@babel/preset-typescript"],
+                        plugins: ["@babel/plugin-proposal-optional-chaining"],
                     },
                 },
             },