@zajno/common 1.2.8 → 1.3.2

package/src/logger/__tests__/{index.test.ts → logger.test.ts}

@@ -1,14 +1,26 @@
 import faker from 'faker';
-import logger, { createLogger, getMode, LoggerFactory, setMode } from '../';
+import logger, { batchLoggers, createLogger, getMode, ILogger, setMode } from '..';
 import fc from 'fast-check';
 import { toArbitrary } from '../../__tests__/helpers/main';
+import { Getter } from '../../types';
 
 const CONSOLE = console;
 
 describe('#logger-tests', () => {
 
-  const customLogger: LoggerFactory = () => ({ log: CONSOLE.log, warn: CONSOLE.warn, error: CONSOLE.error });
-  const loggerMethods = ['log', 'warn', 'error'] as const;
+  const customLogger = {
+    log: jest.fn().mockImplementation(null),
+    warn: jest.fn().mockImplementation(null),
+    error: jest.fn().mockImplementation(null),
+  };
+  const customLoggerGetter = () => customLogger;
+
+  const consoleMocks: Record<keyof ILogger, jest.SpyInstance> = {
+    log: jest.spyOn(CONSOLE, 'log').mockImplementation(null),
+    warn: jest.spyOn(CONSOLE, 'warn').mockImplementation(null),
+    error: jest.spyOn(CONSOLE, 'error').mockImplementation(null),
+  } as const;
+  const loggerMethods = Object.keys(consoleMocks) as (keyof ILogger)[];
 
   it('use logger without mode (default logger)', () => {
     const _textToLog: fc.Arbitrary<string> = toArbitrary(() => faker.internet.url());
@@ -19,10 +31,8 @@ describe('#logger-tests', () => {
         const methodName = loggerMethods[iteration];
         logger[methodName](textToLog);
 
-        const spyCLog = jest.spyOn(CONSOLE, methodName);
-
-        expect(getMode()).toBeFalsy();
-        expect(spyCLog).not.toHaveBeenCalled();
+        expect(getMode()).toBe(false);
+        expect(consoleMocks[methodName]).not.toHaveBeenCalled();
 
         ++iteration;
       }), {
@@ -30,45 +40,45 @@ describe('#logger-tests', () => {
       });
   });
 
-  it('use logger with runtime mode nulling', () => {
+  it('use logger with runtime mode disabling', () => {
     const _textToLog: fc.Arbitrary<string> = toArbitrary(() => faker.random.word());
 
     let iteration = 0;
     fc.assert(
       fc.property(_textToLog, (textToLog) => {
-        if (iteration % 2 === 0) { setMode('console'); setMode(customLogger); setMode(false); }
+        // set mode before or after creating a new logger
+
+        if (iteration % 2 === 0) { setMode('console'); setMode(customLoggerGetter); setMode(false); }
         const logger = createLogger(faker.random.word());
-        if (iteration % 2 === 1) { setMode('console'); setMode(customLogger); setMode(false); }
+        if (iteration % 2 === 1) { setMode('console'); setMode(customLoggerGetter); setMode(false); }
 
         const methodName = loggerMethods[iteration % 3];
         logger[methodName](textToLog);
 
-        const spyLogger = jest.spyOn(customLogger(), methodName);
-
-        expect(getMode()).toBeFalsy();
-        expect(spyLogger).not.toHaveBeenCalled();
+        expect(getMode()).toBe(false);
+        expect(consoleMocks[methodName]).not.toHaveBeenCalled();
         ++iteration;
     }), {
       numRuns: loggerMethods.length * 2,
     });
   });
 
-  it('use logger with \'false\' mode', () => {
+  it('use logger with \'null\' mode', () => {
     const _textToLog: fc.Arbitrary<string> = toArbitrary(() => faker.internet.url());
 
     let iteration = 0;
     fc.assert(
       fc.property(_textToLog, (textToLog) => {
-        if (iteration % 2 === 0) setMode(false);
+        if (iteration % 2 === 0) setMode(null);
         const logger = createLogger(faker.random.word());
-        if (iteration % 2 === 1) setMode(false);
+        if (iteration % 2 === 1) setMode(null);
 
         const methodName = loggerMethods[iteration % 3];
         logger[methodName](textToLog);
 
         const spyLogger = jest.spyOn(CONSOLE, methodName);
 
-        expect(getMode()).toBeFalsy();
+        expect(getMode()).toBeNull();
         expect(spyLogger).not.toHaveBeenCalled();
         ++iteration;
       }), {
@@ -76,75 +86,121 @@ describe('#logger-tests', () => {
       });
   });
 
-  it('use logger with \'null\' mode', () => {
-    const _textToLog: fc.Arbitrary<string> = toArbitrary(() => faker.internet.url());
+  it('use logger with \'console\' mode', () => {
+    const loggerName = `[${faker.random.word()}]`;
+    const _textToLog: fc.Arbitrary<string> = toArbitrary(() => faker.random.word());
 
     let iteration = 0;
     fc.assert(
       fc.property(_textToLog, (textToLog) => {
-        if (iteration % 2 === 0) setMode(null);
-        const logger = createLogger(faker.random.word());
-        if (iteration % 2 === 1) setMode(null);
 
+        if (iteration % 2 === 0) setMode('console');
+        const logger = createLogger(loggerName);
+        if (iteration % 2 === 1) setMode('console');
         const methodName = loggerMethods[iteration % 3];
         logger[methodName](textToLog);
 
-        const spyLogger = jest.spyOn(CONSOLE, methodName);
+        expect(getMode()).toBe('console');
+        expect(consoleMocks[methodName]).toHaveBeenCalledWith(loggerName, textToLog);
+        consoleMocks[methodName].mockClear();
 
-        expect(getMode()).toBeNull();
-        expect(spyLogger).not.toHaveBeenCalled();
         ++iteration;
       }), {
         numRuns: loggerMethods.length * 2,
       });
   });
 
-  it('use logger with \'console\' mode', () => {
+  it('use logger with custom mode', () => {
     const loggerName = `[${faker.random.word()}]`;
     const _textToLog: fc.Arbitrary<string> = toArbitrary(() => faker.random.word());
 
     let iteration = 0;
     fc.assert(
       fc.property(_textToLog, (textToLog) => {
-
-        if (iteration % 2 === 0) setMode('console');
+        if (iteration % 2 === 0) setMode(customLoggerGetter);
         const logger = createLogger(loggerName);
-        if (iteration % 2 === 1) setMode('console');
+        if (iteration % 2 === 1) setMode(customLoggerGetter);
+
         const methodName = loggerMethods[iteration % 3];
         logger[methodName](textToLog);
 
-        const spyLogger = jest.spyOn(CONSOLE, methodName);
+        const impl = customLogger[methodName];
 
-        expect(getMode()).toBe('console');
-        expect(spyLogger).toHaveBeenCalledWith(loggerName, textToLog);
+        expect(getMode()).toBe(customLoggerGetter);
+        expect(impl).toHaveBeenCalledWith(loggerName, textToLog);
+        impl.mockClear();
         ++iteration;
       }), {
         numRuns: loggerMethods.length * 2,
       });
   });
 
-  it('use logger with custom mode', () => {
+  it('use logger with override mode #override', () => {
+
     const loggerName = `[${faker.random.word()}]`;
     const _textToLog: fc.Arbitrary<string> = toArbitrary(() => faker.random.word());
 
+    expect(Getter.getValue(customLoggerGetter as Getter<ILogger>)).toBe(customLogger);
+
+    setMode('console');
+
     let iteration = 0;
     fc.assert(
       fc.property(_textToLog, (textToLog) => {
-        if (iteration % 2 === 0) setMode(customLogger);
-        const logger = createLogger(loggerName);
-        if (iteration % 2 === 1) setMode(customLogger);
+        const loggerDisabled = createLogger(loggerName, false);
+        const loggerCustom = createLogger(loggerName, customLoggerGetter);
+
+        const methodName = loggerMethods[iteration % 3];
+        loggerDisabled[methodName](textToLog);
+        expect(consoleMocks[methodName]).not.toHaveBeenCalled();
+
+        loggerCustom[methodName](textToLog);
+
+        expect(consoleMocks[methodName]).not.toHaveBeenCalled();
+
+        const impl = customLogger[methodName];
+        expect(impl).toHaveBeenCalledWith(loggerName, textToLog);
+        impl.mockClear();
+
+        ++iteration;
+      }), {
+        numRuns: loggerMethods.length,
+      });
+
+    expect(getMode()).toBe('console');
+
+  });
+
+  it('batches loggers', () => {
+
+    const loggerName = `[${faker.random.word()}]`;
+    const _textToLog: fc.Arbitrary<string> = toArbitrary(() => faker.random.word());
+
+    setMode(false);
+
+    let iteration = 0;
+    fc.assert(
+      fc.property(_textToLog, (textToLog) => {
+        const logger = batchLoggers(
+          createLogger(loggerName, 'console'),
+          createLogger(loggerName, customLoggerGetter),
+        );
 
         const methodName = loggerMethods[iteration % 3];
         logger[methodName](textToLog);
 
-        const spyLogger = jest.spyOn(CONSOLE, methodName);
+        expect(consoleMocks[methodName]).toHaveBeenCalledWith(loggerName, textToLog);
+        const impl = customLogger[methodName];
+        expect(impl).toHaveBeenCalledWith(loggerName, textToLog);
+        impl.mockClear();
 
-        expect(getMode()).toBe(customLogger);
-        expect(spyLogger).toHaveBeenCalledWith(loggerName, textToLog);
         ++iteration;
       }), {
-        numRuns: loggerMethods.length * 2,
+        numRuns: loggerMethods.length,
       });
+
+    expect(getMode()).toBe(false);
+
   });
 
 });

package/src/logger/batch.ts

@@ -0,0 +1,9 @@
+import { ILogger } from './abstractions';
+
+export function batchLoggers(...loggers: ILogger[]): ILogger {
+    return {
+        log: (...args) => loggers.forEach(l => l.log(...args)),
+        warn: (...args) => loggers.forEach(l => l.warn(...args)),
+        error: (...args) => loggers.forEach(l => l.error(...args)),
+    };
+}

package/src/logger/console.ts

@@ -4,12 +4,7 @@ import { NamedLogger } from './named';
 export const CONSOLE: ILogger = console;
 
 export class ConsoleLogger extends NamedLogger {
-
     protected get implementation() { return CONSOLE; }
-
-    constructor(name?: string, enabled = true) {
-        super(name, enabled);
-    }
 }
 
 export class BufferedConsoleLogger implements ILogger {

package/src/logger/file.ts

@@ -0,0 +1,46 @@
+import * as FS from 'fs';
+import * as Util from 'util';
+import { ILogger } from './abstractions';
+import { Getter } from '../types';
+
+export class FileLoggerNode implements ILogger {
+    private readonly _buffer: string[];
+
+    constructor(readonly fileName: Getter<string>, bufferMode = false) {
+        this._buffer = bufferMode ? [] : null;
+    }
+
+    /** @example Path.resolve(__dirname, `../run.${new Date().toISOString()}.log`) */
+    private get logFilePath() { return Getter.getValue(this.fileName); }
+
+    log = (...args: any[]) => {
+        this.appendToFile(...args);
+    };
+
+    warn(...args: any[]) {
+        this.appendToFile(...args);
+    }
+
+    error(...args: any[]) {
+        this.appendToFile(...args);
+    }
+
+    public flush() {
+        if (!this._buffer) {
+            return;
+        }
+
+        FS.writeFileSync(this.logFilePath, this._buffer.join(''));
+        this._buffer.length = 0;
+    }
+
+    private appendToFile(..._args: any[]) {
+        // @ts-ignore
+        const str = Util.format.apply(null, arguments) + '\n';
+        if (this._buffer) {
+            this._buffer.push(str);
+        } else {
+            FS.appendFileSync(this.logFilePath, str);
+        }
+    }
+}

package/src/logger/index.ts

@@ -1,44 +1,36 @@
+import { Getter } from '../types';
 import { ILogger, LoggerFunction } from './abstractions';
 import { CONSOLE, ConsoleLogger } from './console';
-import { EMPTY_LOGGER, ProxyLogger } from './proxy';
+import { ProxyLogger } from './proxy';
+import { batchLoggers } from './batch';
+import { removeItem } from '../math';
 
 export { NamedLogger } from './named';
-export { ILogger, LoggerFunction };
-export { ConsoleLogger };
+export { ILogger, LoggerFunction, ConsoleLogger, batchLoggers };
 
 // TBD Introduce more logger types ?
 export type LoggerTypes = 'console';
-export type LoggerFactory = (() => ILogger);
 
-let Mode: LoggerTypes | false | LoggerFactory = process.env.COMMON_UTILS_LOGGER as LoggerTypes || false;
+let Mode: LoggerTypes | false | Getter<ILogger> = process.env.COMMON_UTILS_LOGGER as LoggerTypes || false;
 
 const proxies: ProxyLogger[] = [];
 
-function _createImplementation(): ILogger {
-    switch (Mode) {
-        case 'console': {
-            return CONSOLE;
-        }
-
-        case false: {
-            return EMPTY_LOGGER;
-        }
-
-        default: {
-            if (typeof Mode === 'function') {
-                return Mode();
-            }
+export function createLogger(name: string, mode: typeof Mode = undefined): ILogger {
+    const result = _createImplementation(mode);
+    const proxy = new ProxyLogger(result, name);
+    proxies.push(proxy);
+    return proxy;
+}
 
-            return undefined;
+export function detachLogger(instance: ILogger, terminate = false) {
+    const item = removeItem(proxies, instance as ProxyLogger);
+    if (item) {
+        if (terminate) {
+            item.disable();
         }
+        return true;
     }
-}
-
-export function createLogger(name: string, forceDisable = false): ILogger {
-    const result = _createImplementation();
-    const proxy = new ProxyLogger(result, name, !forceDisable);
-    proxies.push(proxy);
-    return proxy;
+    return false;
 }
 
 export function setMode(mode: typeof Mode) {
@@ -57,6 +49,23 @@ export function setMode(mode: typeof Mode) {
 
 export function getMode() { return Mode; }
 
-const logger: ILogger = createLogger('', false);
+const logger: ILogger = createLogger(null, false);
 
 export default logger;
+
+function _createImplementation(overrideMode: typeof Mode = undefined): ILogger {
+    const mode = overrideMode !== undefined ? overrideMode : Mode;
+    switch (mode) {
+        case 'console': {
+            return CONSOLE;
+        }
+
+        case false: {
+            return null;
+        }
+
+        default: {
+            return Getter.getValue(mode as Getter<ILogger>);
+        }
+    }
+}

package/src/logger/named.ts

@@ -28,15 +28,15 @@ export abstract class NamedLogger implements ILogger, ILoggerSwitchable {
 
         this.log = this._name
             ? (...args) => this.implementation.log(this._name, ...args)
-            : (...args) => this.implementation.log(...args);
+            : this.implementation.log;
 
         this.warn = this._name
             ? (...args) => this.implementation.warn(this._name, ...args)
-            : (...args) => this.implementation.warn(...args);
+            : this.implementation.warn;
 
         this.error = this._name
             ? (...args) => this.implementation.error(this._name, ...args)
-            : (...args) => this.implementation.error(...args);
+            : this.implementation.error;
     }
 
     disable() {

package/src/logger/proxy.ts

@@ -13,8 +13,8 @@ export class ProxyLogger extends NamedLogger {
 
     private _logger: ILogger = null;
 
-    constructor(logger: ILogger, name?: string, enabled = true) {
-        super(name, enabled);
+    constructor(logger: ILogger, name: string) {
+        super(name, logger != null);
         this._logger = logger;
     }
 

package/src/math/__tests__/arrays.test.ts

@@ -64,6 +64,45 @@ describe('math/arrays', () => {
         expect(arrays.arrayFirstResult([1, 2, 3], i => i == 2 ? 'pass' : false)).toBe('pass');
     });
 
+    it('arraysCompare', () => {
+        expect(arrays.arraysCompare(null, null)).toBeNull();
+        expect(arrays.arraysCompare([], null)).toBeNull();
+
+        const result = (missing, extra, diff) => ({ missing, extra, diff });
+
+        expect(arrays.arraysCompare([], [])).toStrictEqual(result([], [], 0));
+        expect(arrays.arraysCompare([1], [])).toStrictEqual(result([1], [], 1));
+        expect(arrays.arraysCompare([1, 2], [1])).toStrictEqual(result([2], [], 1));
+        expect(arrays.arraysCompare([1], [1])).toStrictEqual(result([], [], 0));
+        expect(arrays.arraysCompare([], [1])).toStrictEqual(result([], [1], 1));
+        expect(arrays.arraysCompare([1, 2, 3], [3, 2, 1])).toStrictEqual(result([1, 3], [], 2));
+    });
+
+    it('arraysCompareDistinct', () => {
+        expect(arrays.arraysCompareDistinct(null, null)).toBeNull();
+        expect(arrays.arraysCompareDistinct([], null)).toBeNull();
+
+        const result = (missing, extra, diff) => ({ missing, extra, diff });
+
+        expect(arrays.arraysCompareDistinct([], [])).toStrictEqual(result([], [], 0));
+        expect(arrays.arraysCompareDistinct([1], [])).toStrictEqual(result([1], [], 1));
+        expect(arrays.arraysCompareDistinct([1, 2], [1])).toStrictEqual(result([2], [], 1));
+        expect(arrays.arraysCompareDistinct([1], [1])).toStrictEqual(result([], [], 0));
+        expect(arrays.arraysCompareDistinct([], [1])).toStrictEqual(result([], [1], 1));
+        expect(arrays.arraysCompareDistinct([1, 2], [2, 1, 1])).toStrictEqual(result([], [], 0));
+        expect(arrays.arraysCompareDistinct([1, 2, 3], [3, 2, 1])).toStrictEqual(result([], [], 0));
+    });
+
+    it('arrayDistinct', () => {
+        expect(arrays.arrayDistinct(null)).toStrictEqual([]);
+        expect(arrays.arrayDistinct([])).toStrictEqual([]);
+        expect(arrays.arrayDistinct([1])).toStrictEqual([1]);
+        expect(arrays.arrayDistinct([1, 2, 3])).toStrictEqual([1, 2, 3]);
+        expect(arrays.arrayDistinct([1, '2', 3])).toStrictEqual([1, '2', 3]);
+        expect(arrays.arrayDistinct([1, 1, 1])).toStrictEqual([1]);
+        expect(arrays.arrayDistinct(['1', '1', '1'])).toStrictEqual(['1']);
+    });
+
     it('normalize', () => {
         expect(arrays.normalize([])).toHaveLength(0);
 
@@ -85,8 +124,12 @@ describe('math/arrays', () => {
     });
 
     it('shuffle', () => {
+        expect(arrays.shuffle(null)).toStrictEqual([]);
+        expect(arrays.shuffle(null, true)).toStrictEqual([]);
+
         const arr1 = [1, 2, 3], arr2 = arr1.slice();
         arrays.shuffle(arr2);
+        arrays.shuffle(arr2, true);
         expect(arr2).toHaveLength(arr1.length);
         arr2.forEach(i => {
             expect(arr1).toContain(i);
@@ -138,6 +181,16 @@ describe('math/arrays', () => {
         expect(arrays.findIndexLeast(2, [3, 2, 1])).toBe(0);
         expect(arrays.findIndexLeast(2, [3, 2, 1], true)).toBe(2);
         expect(arrays.findIndexLeast(2, [1, 2, 3])).toBe(2);
+    });
+
+    it('removeItem', () => {
+        const check = (input: any[], remove: any, output: any[]) => {
+            arrays.removeItem(input, remove);
+            expect(input).toStrictEqual(output);
+        };
 
+        check([1, 2, 3], 1, [2, 3]);
+        check([1, 2, 3], item => item === 1, [2, 3]);
+        check([1, 2, 3], '1', [1, 2, 3]);
     });
 });

package/src/math/arrays.ts

@@ -1,3 +1,4 @@
+import { Comparator, Predicate } from '../types';
 import { random } from './calc';
 
 export function arrayCompareG<T>(arr: ReadonlyArray<T>, cond: (current: T, previous: T) => boolean): T {
@@ -81,6 +82,71 @@ export function arrayFirstResult<T, V>(arr: ReadonlyArray<T>, mapper: (o: T) =>
     return false;
 }
 
+export function arraysCompare<T>(base: readonly T[], target: readonly T[], comparator?: Comparator<T>) {
+    if (!base || !target) {
+        return null;
+    }
+
+    const compare = comparator || Comparator.Default;
+    const result = {
+        missing: [] as T[],
+        extra: [] as T[],
+        diff: 0,
+    };
+
+    for (let i = 0; i < base.length; ++i) {
+        const baseItem = base[i];
+        const targetItem = target[i];
+        if (compare(baseItem, targetItem)) {
+            continue;
+        }
+
+        result.missing.push(baseItem);
+    }
+
+    for (let i = base.length; i < target.length; ++i) {
+        result.extra.push(target[i]);
+    }
+
+    result.diff = result.missing.length + result.extra.length;
+    return result;
+}
+
+export function arraysCompareDistinct<T>(base: readonly T[], target: readonly T[]) {
+    if (!base || !target) {
+        return null;
+    }
+
+    const baseSet = new Set(base);
+    const targetSet = new Set(target);
+    const result = {
+        missing: [] as T[],
+        extra: [] as T[],
+        diff: 0,
+    };
+
+    for (const item of baseSet) {
+        if (!targetSet.has(item)) {
+            result.missing.push(item);
+        } else {
+            // reduce iterations for 'extra'
+            targetSet.delete(item);
+        }
+    }
+
+    for (const item of targetSet) {
+        // all items left in 'target' is missing in 'base'
+        result.extra.push(item);
+    }
+
+    result.diff = result.missing.length + result.extra.length;
+    return result;
+}
+
+export function arrayDistinct<T>(arr: readonly T[]) {
+    return Array.from(new Set(arr || []));
+}
+
 export function normalize(arr: number[]): number[] {
     if (arr.length === 0) {
         return arr;
@@ -172,3 +238,16 @@ export function findIndexLeast(num: number, arr: number[], sort = false) {
 
     return arr.findIndex(i => i > num);
 }
+
+type NonFunction<T> = T extends Function ? never : T;
+
+export function removeItem<T>(array: T[], item: NonFunction<T> | Predicate<T>): T {
+    const index = typeof item === 'function'
+        ? array.findIndex(item as Predicate<T>)
+        : array.indexOf(item);
+    if (index < 0) {
+        return null;
+    }
+
+    return array.splice(index, 1)[0];
+}

package/src/transitionObserver.ts

@@ -20,7 +20,7 @@ export class TransitionObserver<T> implements IDisposable {
     private _promise: Promise<T> = null;
     private _promiseReject: (err?: any) => any = null;
 
-    private logger: ILogger = createLogger('', true);
+    private logger: ILogger = createLogger('', false);
 
     constructor(getter?: () => T) {
         if (getter) {
@@ -115,7 +115,7 @@ export class TransitionObserver<T> implements IDisposable {
     }
 
     enableLogging(name: string) {
-        this.logger = createLogger(name, !name);
+        this.logger = createLogger(name, name ? undefined : false);
         return this;
     }
 

package/src/types.ts

@@ -3,3 +3,24 @@ export { DeepPartial } from './deepPartial';
 export type DeepReadonly<T> = {
     readonly [P in keyof T]: DeepReadonly<T[P]>;
 };
+
+export type Getter<T> = (() => T) | T | null;
+
+export namespace Getter {
+    export function getValue<T>(getter: Getter<T>): T {
+        if (getter == null) {
+            return undefined;
+        }
+        if (typeof getter === 'function') {
+            return (getter as () => T)();
+        }
+        return getter;
+    }
+}
+
+export type Predicate<T> = (value: T) => boolean;
+export type Comparator<T, C = boolean> = (v1: T, v2: T) => C;
+
+export namespace Comparator {
+    export const Default: Comparator<any> = (a, b) => a === b;
+}