Introduce basic pre/post processor logic (#96)

* Intorduce pro/post processors

* Implement tests

* Fix lint

* Fix test coverage and remove method scope processors

* Fix generics

* More options for processors

* JsDocs

src/index.ts

@@ -48,7 +48,7 @@ export type SharedConfig = {
     paddingChar?: string;
 };
 
-export type LogConfig = SharedConfig & {
+export type LogConfig<M extends string> = SharedConfig & {
     /**
      * Wether to add spacing in front or behind the specified label
      * @default "PREPEND"
@@ -72,6 +72,20 @@ export type LogConfig = SharedConfig & {
      * @example ['error', 'important', 'success'] (only logs error, important, and success)
      */
     filter: RuntimeOrValue<string[] | undefined>;
+
+    /**
+     * A list of functions to handle input pre processing
+     * @default []
+     * @example [(in) => in]
+     */
+    preProcessors?: ((input: LogMethodInput[], method: { name: M } & MethodConfig, logger: LogConfig<M>) => LogMethodInput[])[];
+
+    /**
+     * A list of functions to handle input post processing
+     * @default []
+     * @example [(lines) => lines]
+     */
+    postProcessors?: ((lines: string[], method: { name: M } & MethodConfig, logger: LogConfig<M>) => string[])[];
 };
 
 /**
@@ -145,7 +159,7 @@ export const pad = (
  */
 export const createLogger = <A extends string>(
     methods: MethodList<A> | MethodList<A>[],
-    config: Partial<LogConfig> = {},
+    config: Partial<LogConfig<A>> = {},
     outputFunctions: GenericLogFunction | GenericLogFunction[] = console.log
 ) => {
     const functions: GenericLogFunction[] = Array.isArray(outputFunctions)
@@ -158,7 +172,7 @@ export const createLogger = <A extends string>(
         : methods;
 
     // Fill default values incase not overridden by arg
-    const completeConfig: LogConfig = {
+    const completeConfig: Required<LogConfig<A>> = {
         divider: ' ',
         newLine: '├-',
         newLineEnd: '└-',
@@ -167,6 +181,8 @@ export const createLogger = <A extends string>(
         color: true,
         exclude: [],
         filter: undefined,
+        preProcessors: [],
+        postProcessors: [],
         ...config,
     };
 
@@ -261,8 +277,14 @@ export const createLogger = <A extends string>(
                     )
                         return;
 
+                    let inputs = s;
+
+                    for(const processor of completeConfig.preProcessors) {
+                        inputs = processor(inputs, { name: methodHandle as A, ...method }, completeConfig);
+                    }
+
                     // Generate the value we should output
-                    const value = s
+                    const lines = inputs
                         .map((value) => {
                             if (typeof value !== 'string') {
                                 value = inspect(
@@ -292,8 +314,15 @@ export const createLogger = <A extends string>(
                                         ? newLineEndPadding
                                         : newLinePadding) + method.divider) +
                                 value
-                        )
-                        .join('\n');
+                        );
+
+                    let parsedLines = lines;
+
+                    for(const processor of completeConfig.postProcessors) {
+                        parsedLines = processor(parsedLines, { name: methodHandle as A, ...method }, completeConfig);
+                    }
+
+                    const value = parsedLines.join('\n');
 
                     // Run each of the final functions
                     for (const a of functions) a(value);

tests/logger.test.ts

@@ -1,6 +1,6 @@
 import chalk from 'chalk';
 
-import { createLogger, Logger, shimLog } from '../src';
+import { createLogger, Logger } from '../src';
 
 const logFunction = jest.fn();
 

tests/postprocessors.test.ts

@@ -0,0 +1,51 @@
+import chalk from 'chalk';
+
+import { createLogger, Logger } from '../src';
+
+const logFunction = jest.fn();
+
+describe('Post Process Logging', () => {
+    let logger: Logger<'ok'>;
+
+    beforeAll(() => {
+        logger = createLogger(
+            {
+                ok: {
+                    label: chalk.greenBright`[OK]`,
+                    newLine: '| ',
+                    newLineEnd: '\\-',
+                },
+            },
+            {
+                padding: 'PREPEND',
+                color: false,
+                postProcessors: [
+                    (lines, { name }) => {
+                        let index = 0;
+
+                        return lines.map(it => `[Called ${name} ${++index} times] ${it}`);
+                    }
+                ]
+            },
+            logFunction
+        );
+    });
+
+    afterEach(() => {
+        jest.clearAllMocks();
+    });
+
+    it('should log with pre-processor', () => {
+        logger.ok(
+            'This is the best logging library',
+            'It\'s not even a question',
+            'It even supports multi\nline logs'
+        );
+        expect(logFunction).toBeCalledWith(
+            `[Called ok 1 times] ${chalk.greenBright('[OK]')} This is the best logging library\n` +
+            '[Called ok 2 times]   |  It\'s not even a question\n' +
+            '[Called ok 3 times]   |  It even supports multi\n' +
+            '[Called ok 4 times]   \\- line logs'
+        );
+    });
+});

tests/preprocessors.test.ts

@@ -0,0 +1,51 @@
+import chalk from 'chalk';
+
+import { createLogger, Logger } from '../src';
+
+const logFunction = jest.fn();
+
+describe('Pre Process Logging', () => {
+    let logger: Logger<'ok'>;
+
+    beforeAll(() => {
+        logger = createLogger(
+            {
+                ok: {
+                    label: chalk.greenBright`[OK]`,
+                    newLine: '| ',
+                    newLineEnd: '\\-',
+                },
+            },
+            {
+                padding: 'PREPEND',
+                color: false,
+                preProcessors: [
+                    (inputs, { name }) => {
+                        let index = 0;
+
+                        return inputs.map(it => `[Called ${name} ${++index} times] ${it}`);
+                    }
+                ]
+            },
+            logFunction
+        );
+    });
+
+    afterEach(() => {
+        jest.clearAllMocks();
+    });
+
+    it('should log with pre-processor', () => {
+        logger.ok(
+            'This is the best logging library',
+            'It\'s not even a question',
+            'It even supports multi\nline logs'
+        );
+        expect(logFunction).toBeCalledWith(
+            `${chalk.greenBright('[OK]')} [Called ok 1 times] This is the best logging library\n` +
+            '  |  [Called ok 2 times] It\'s not even a question\n' +
+            '  |  [Called ok 3 times] It even supports multi\n' +
+            '  \\- line logs'
+        );
+    });
+});

tests/randomlogconfig.test.ts

@@ -1,6 +1,6 @@
 import chalk from 'chalk';
 
-import { createLogger, Logger } from '../src';
+import { createLogger, GenericLogFunction, Logger } from '../src';
 
 const logFunction = jest.fn<void, [string]>();
 
@@ -38,7 +38,7 @@ describe('Random Config', () => {
                 },
             ],
             { padding: 'PREPEND', color: false },
-            logFunction
+            logFunction as GenericLogFunction
         );
     });