@zajno/common 1.1.14 → 1.2.3

package/src/logger/console.ts

@@ -1,13 +1,11 @@
-import { ILogger, LoggerFunction } from './abstractions';
+import { ILogger } from './abstractions';
 import { NamedLogger } from './named';
 
-const CONSOLE = console;
+export const CONSOLE: ILogger = console;
 
 export class ConsoleLogger extends NamedLogger {
 
-    protected get logFunction(): LoggerFunction { return CONSOLE.log; }
-    protected get warnFunction(): LoggerFunction { return CONSOLE.warn; }
-    protected get errorFunction(): LoggerFunction { return CONSOLE.error; }
+    protected get implementation() { return CONSOLE; }
 
     constructor(name?: string, enabled = true) {
         super(name, enabled);

package/src/logger/index.ts

@@ -1,5 +1,6 @@
-import { ILogger, ILoggerSwitchable, LoggerFunction } from './abstractions';
-import { ConsoleLogger } from './console';
+import { ILogger, LoggerFunction } from './abstractions';
+import { CONSOLE, ConsoleLogger } from './console';
+import { EMPTY_LOGGER, ProxyLogger } from './proxy';
 
 export { NamedLogger } from './named';
 export { ILogger, LoggerFunction };
@@ -7,40 +8,55 @@ export { ConsoleLogger };
 
 // TBD Introduce more logger types ?
 export type LoggerTypes = 'console';
+export type LoggerFactory = (() => ILogger);
 
-let Enabled: LoggerTypes | false = process.env.COMMON_UTILS_LOGGER as LoggerTypes || false;
+let Mode: LoggerTypes | false | LoggerFactory = process.env.COMMON_UTILS_LOGGER as LoggerTypes || false;
 
-const createdLoggers: ILoggerSwitchable[] = [];
+const proxies: ProxyLogger[] = [];
 
-function _create(name: string, forceDisable: boolean) {
-    switch (Enabled) {
+function _createImplementation(): ILogger {
+    switch (Mode) {
         case 'console': {
-            return new ConsoleLogger(name, !forceDisable);
+            return CONSOLE;
+        }
+
+        case false: {
+            return EMPTY_LOGGER;
         }
 
         default: {
-            return new ConsoleLogger(name, false);
+            if (typeof Mode === 'function') {
+                return Mode();
+            }
+
+            return undefined;
         }
     }
 }
 
-export function createLogger(name = '', forceDisable = false): ILogger {
-    const result = _create(name, forceDisable);
-    createdLoggers.push(result);
-    return result;
+export function createLogger(name: string, forceDisable = false): ILogger {
+    const result = _createImplementation();
+    const proxy = new ProxyLogger(result, name, !forceDisable);
+    proxies.push(proxy);
+    return proxy;
 }
 
-const logger = new ConsoleLogger('', !!Enabled);
-createdLoggers.push(logger);
+export function setMode(mode: typeof Mode) {
+    if (Mode === mode) {
+        return;
+    }
 
-export function setEnabled(enabled: LoggerTypes | false) {
-    Enabled = enabled;
+    Mode = mode;
 
-    if (!Enabled) {
-        createdLoggers.forEach(l => l.disable());
+    if (!Mode) {
+        proxies.forEach(l => l.disable());
     } else {
-        createdLoggers.forEach(l => l.enable());
+        proxies.forEach(l => l.setLogger(_createImplementation()));
     }
 }
 
-export default logger as ILogger;
+export function getMode() { return Mode; }
+
+const logger: ILogger = createLogger('', false);
+
+export default logger;

package/src/logger/named.ts

@@ -1,25 +1,17 @@
 import { ILogger, ILoggerSwitchable, LoggerFunction } from './abstractions';
 
-const EMPTY_FUNCTION = () => { /* no-op */ };
-
-function addArg(func: (...args: any[]) => any, value: string) {
-    return (...args: any[]) => func(value, ...args);
-}
+export const EMPTY_FUNCTION = () => { /* no-op */ };
 
 export abstract class NamedLogger implements ILogger, ILoggerSwitchable {
-    private _log: LoggerFunction = null;
-    private _warn: LoggerFunction = null;
-    private _error: LoggerFunction = null;
+    public log: LoggerFunction = null;
+    public warn: LoggerFunction = null;
+    public error: LoggerFunction = null;
 
     private _name: string = null;
 
-    get log() { return this._log; }
-    get warn() { return this._warn; }
-    get error() { return this._error; }
+    get name() { return this._name; }
 
-    protected abstract get logFunction(): LoggerFunction;
-    protected abstract get warnFunction(): LoggerFunction;
-    protected abstract get errorFunction(): LoggerFunction;
+    protected abstract get implementation(): ILogger;
 
     constructor(name?: string, enabled = true) {
         this._name = name;
@@ -34,20 +26,22 @@ export abstract class NamedLogger implements ILogger, ILoggerSwitchable {
     enable(overrideName = null) {
         this._name = overrideName || this._name;
 
-        this._log = this._name
-            ? addArg(this.logFunction, this._name)
-            : this.logFunction;
-        this._warn = this._name
-            ? addArg(this.warnFunction, this._name)
-            : this.warnFunction;
-        this._error = this._name
-            ? addArg(this.errorFunction, this._name)
-            : this.errorFunction;
+        this.log = this._name
+            ? (...args) => this.implementation.log(this._name, ...args)
+            : (...args) => this.implementation.log(...args);
+
+        this.warn = this._name
+            ? (...args) => this.implementation.warn(this._name, ...args)
+            : (...args) => this.implementation.warn(...args);
+
+        this.error = this._name
+            ? (...args) => this.implementation.error(this._name, ...args)
+            : (...args) => this.implementation.error(...args);
     }
 
     disable() {
-        this._log = EMPTY_FUNCTION;
-        this._warn = EMPTY_FUNCTION;
-        this._error = EMPTY_FUNCTION;
+        this.log = EMPTY_FUNCTION;
+        this.warn = EMPTY_FUNCTION;
+        this.error = EMPTY_FUNCTION;
     }
 }

package/src/logger/proxy.ts

@@ -0,0 +1,29 @@
+import { ILogger } from './abstractions';
+import { EMPTY_FUNCTION, NamedLogger } from './named';
+
+export const EMPTY_LOGGER: ILogger = {
+    log: EMPTY_FUNCTION,
+    warn: EMPTY_FUNCTION,
+    error: EMPTY_FUNCTION,
+};
+
+export class ProxyLogger extends NamedLogger {
+
+    protected get implementation() { return this._logger || EMPTY_LOGGER; }
+
+    private _logger: ILogger = null;
+
+    constructor(logger: ILogger, name?: string, enabled = true) {
+        super(name, enabled);
+        this._logger = logger;
+    }
+
+    public setLogger(logger: ILogger) {
+        this._logger = logger || null;
+        if (this._logger) {
+            this.enable();
+        } else {
+            this.disable();
+        }
+    }
+}

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

@@ -17,43 +17,43 @@ describe('math/arrays', () => {
 
         expect(() => arrays.arrayCompare([1, 2, 3], false, null)).toThrow();
 
-        expect(arrays.arrayCompare([1, 2, 3], false, (i, t) => i > t)).toEqual(3);
-        expect(arrays.arrayCompare([1, 2, 3], false, (i, t) => i < t)).toEqual(1);
+        expect(arrays.arrayCompare([1, 2, 3], false, (i, t) => i > t)).toBe(3);
+        expect(arrays.arrayCompare([1, 2, 3], false, (i, t) => i < t)).toBe(1);
 
-        expect(arrays.arrayCompare([-1, 2, -3], true, (i, t) => i > t)).toEqual(3);
+        expect(arrays.arrayCompare([-1, 2, -3], true, (i, t) => i > t)).toBe(3);
         expect(arrays.arrayCompare([-1, 2, -3], true, (i, t) => i < t)).toEqual(-1);
     });
 
     it('arrayMax', () => {
         expect(arrays.arrayMax([], false)).toBeNull();
-        expect(arrays.arrayMax([1, 2, 3], false)).toEqual(3);
-        expect(arrays.arrayMax([-1, 2, -3], true)).toEqual(3);
+        expect(arrays.arrayMax([1, 2, 3], false)).toBe(3);
+        expect(arrays.arrayMax([-1, 2, -3], true)).toBe(3);
     });
 
     it('arrayMin', () => {
         expect(arrays.arrayMin([], false)).toBeNull();
-        expect(arrays.arrayMin([1, 2, 3], false)).toEqual(1);
+        expect(arrays.arrayMin([1, 2, 3], false)).toBe(1);
         expect(arrays.arrayMin([-1, 2, -3], true)).toEqual(-1);
     });
 
     it('arrayAverage', () => {
-        expect(arrays.arrayAverage(null)).toEqual(0);
-        expect(arrays.arrayAverage([])).toEqual(0);
-        expect(arrays.arrayAverage([1, 2, 3])).toEqual(2);
+        expect(arrays.arrayAverage(null)).toBe(0);
+        expect(arrays.arrayAverage([])).toBe(0);
+        expect(arrays.arrayAverage([1, 2, 3])).toBe(2);
         expect(arrays.arrayAverage([-2, 2, -3])).toEqual(-1);
-        expect(arrays.arrayAverage([-1, 2, -3], true)).toEqual(2);
+        expect(arrays.arrayAverage([-1, 2, -3], true)).toBe(2);
     });
 
     it('arrayCount', () => {
-        expect(arrays.arrayCount(null, null)).toEqual(0);
-        expect(arrays.arrayCount([], null)).toEqual(0);
+        expect(arrays.arrayCount(null, null)).toBe(0);
+        expect(arrays.arrayCount([], null)).toBe(0);
 
         expect(() => arrays.arrayCount([1, 2, 3], null)).toThrow();
-        expect(arrays.arrayCount([1, 2, 3], i => i >= 2)).toEqual(2);
+        expect(arrays.arrayCount([1, 2, 3], i => i >= 2)).toBe(2);
 
         type T = { a: number };
         const tArr: T[] = [ { a: 1 }, { a: 2 }, { a: 3 } ];
-        expect(arrays.arrayCount(tArr, i => i.a >= 2)).toEqual(2);
+        expect(arrays.arrayCount(tArr, i => i.a >= 2)).toBe(2);
     });
 
     it('arrayFirstResult', () => {
@@ -61,7 +61,7 @@ describe('math/arrays', () => {
         expect(arrays.arrayFirstResult([], null)).toBeFalsy();
 
         expect(() => arrays.arrayFirstResult([1, 2, 3], null)).toThrow();
-        expect(arrays.arrayFirstResult([1, 2, 3], i => i == 2 ? 'pass' : false)).toEqual('pass');
+        expect(arrays.arrayFirstResult([1, 2, 3], i => i == 2 ? 'pass' : false)).toBe('pass');
     });
 
     it('normalize', () => {
@@ -75,7 +75,7 @@ describe('math/arrays', () => {
         expect(() => arrays.randomArrayItem(null)).toThrow();
         expect(arrays.randomArrayItem([])).toBeNull();
 
-        expect(arrays.randomArrayItem([1])).toEqual(1);
+        expect(arrays.randomArrayItem([1])).toBe(1);
         expect([1, 2, 3]).toContain(arrays.randomArrayItem([1, 2, 3]));
 
         const arr1 = [1, 2, 3], arr2 = arr1.slice();
@@ -135,9 +135,9 @@ describe('math/arrays', () => {
     it('findIndexLeast', () => {
         expect(() => arrays.findIndexLeast(0, null)).toThrow();
 
-        expect(arrays.findIndexLeast(2, [3, 2, 1])).toEqual(0);
-        expect(arrays.findIndexLeast(2, [3, 2, 1], true)).toEqual(2);
-        expect(arrays.findIndexLeast(2, [1, 2, 3])).toEqual(2);
+        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);
 
     });
 });

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

@@ -2,29 +2,29 @@ import * as calc from '../calc';
 
 describe('math/calc', () => {
     it('clamp', () => {
-        expect(calc.clamp(123)).toEqual(123);
-        expect(calc.clamp(123, 10)).toEqual(123);
-        expect(calc.clamp(0, 1, 2, false)).toEqual(1);
-        expect(calc.clamp(0, 1, 2, true)).toEqual(2);
-        expect(calc.clamp(3, 1, 2, false)).toEqual(2);
-        expect(calc.clamp(3, 1, 2, true)).toEqual(1);
-        expect(calc.clamp(15, 10, 20, false)).toEqual(15);
-        expect(calc.clamp(15, 10, 20, true)).toEqual(15);
+        expect(calc.clamp(123)).toBe(123);
+        expect(calc.clamp(123, 10)).toBe(123);
+        expect(calc.clamp(0, 1, 2, false)).toBe(1);
+        expect(calc.clamp(0, 1, 2, true)).toBe(2);
+        expect(calc.clamp(3, 1, 2, false)).toBe(2);
+        expect(calc.clamp(3, 1, 2, true)).toBe(1);
+        expect(calc.clamp(15, 10, 20, false)).toBe(15);
+        expect(calc.clamp(15, 10, 20, true)).toBe(15);
     });
 
     it('clamp01', () => {
-        expect(calc.clamp01(-1)).toEqual(0);
-        expect(calc.clamp01(0)).toEqual(0);
-        expect(calc.clamp01(0.5)).toEqual(0.5);
-        expect(calc.clamp01(1)).toEqual(1);
-        expect(calc.clamp01(2)).toEqual(1);
+        expect(calc.clamp01(-1)).toBe(0);
+        expect(calc.clamp01(0)).toBe(0);
+        expect(calc.clamp01(0.5)).toBe(0.5);
+        expect(calc.clamp01(1)).toBe(1);
+        expect(calc.clamp01(2)).toBe(1);
     });
 
     it('contains', () => {
-        expect(calc.contains(1, 2, 3)).toEqual(false);
-        expect(calc.contains(1, 3, 2)).toEqual(false);
-        expect(calc.contains(15, 10, 20)).toEqual(true);
-        expect(calc.contains(15, 20, 10)).toEqual(true);
+        expect(calc.contains(1, 2, 3)).toBe(false);
+        expect(calc.contains(1, 3, 2)).toBe(false);
+        expect(calc.contains(15, 10, 20)).toBe(true);
+        expect(calc.contains(15, 20, 10)).toBe(true);
     });
 
     it('getIntersection', () => {
@@ -33,20 +33,20 @@ describe('math/calc', () => {
     });
 
     it('roundNumber', () => {
-        expect(calc.roundNumber(10)).toEqual(10);
-        expect(calc.roundNumber(10.1)).toEqual(10.1);
-        expect(calc.roundNumber(10.12)).toEqual(10.12);
-        expect(calc.roundNumber(10.123)).toEqual(10.12);
-        expect(calc.roundNumber(10.1234)).toEqual(10.12);
-        expect(calc.roundNumber(10.1234, 4)).toEqual(10.1234);
-        expect(calc.roundNumber(10.1235, 3)).toEqual(10.124);
-        expect(calc.roundNumber(10.1234, 3, 'ceil')).toEqual(10.124);
-        expect(calc.roundNumber(10.1239, 3, 'floor')).toEqual(10.123);
+        expect(calc.roundNumber(10)).toBe(10);
+        expect(calc.roundNumber(10.1)).toBe(10.1);
+        expect(calc.roundNumber(10.12)).toBe(10.12);
+        expect(calc.roundNumber(10.123)).toBe(10.12);
+        expect(calc.roundNumber(10.1234)).toBe(10.12);
+        expect(calc.roundNumber(10.1234, 4)).toBe(10.1234);
+        expect(calc.roundNumber(10.1235, 3)).toBe(10.124);
+        expect(calc.roundNumber(10.1234, 3, 'ceil')).toBe(10.124);
+        expect(calc.roundNumber(10.1239, 3, 'floor')).toBe(10.123);
     });
 
     it('roundHalf', () => {
-        expect(calc.roundHalf(12.213)).toEqual(12);
-        expect(calc.roundHalf(12.999)).toEqual(13);
+        expect(calc.roundHalf(12.213)).toBe(12);
+        expect(calc.roundHalf(12.999)).toBe(13);
     });
 
     describe('random', () => {

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

@@ -6,20 +6,20 @@ describe('math/distribution', () => {
 
         const r1 = distribution.extendDistribution<TKeys>(1, 'type1');
         expect(r1).toBeTruthy();
-        expect(r1.total).toEqual(1);
-        expect(r1.byType.type1).toEqual(1);
+        expect(r1.total).toBe(1);
+        expect(r1.byType.type1).toBe(1);
 
         distribution.extendDistribution(3, 'type2', r1);
-        expect(r1.total).toEqual(4);
-        expect(r1.byType.type1).toEqual(1);
-        expect(r1.byType.type2).toEqual(3);
+        expect(r1.total).toBe(4);
+        expect(r1.byType.type1).toBe(1);
+        expect(r1.byType.type2).toBe(3);
 
         const d: distribution.Distribution<TKeys> = { total: 0, byType: null };
         distribution.extendDistribution(1, 'type1', d);
-        expect(d.total).toEqual(1);
-        expect(d.byType.type1).toEqual(1);
+        expect(d.total).toBe(1);
+        expect(d.byType.type1).toBe(1);
         expect(d.byType.type2).toBeUndefined();
 
-        expect(distribution.extendDistribution(0, 'type1').total).toEqual(0);
+        expect(distribution.extendDistribution(0, 'type1').total).toBe(0);
     });
 });

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

@@ -2,19 +2,19 @@ import * as math from '../index';
 
 describe('math', () => {
     it('getNumberSuffix', () => {
-        expect(math.getNumberSuffix(1)).toEqual('st');
-        expect(math.getNumberSuffix(11)).toEqual('st');
-        expect(math.getNumberSuffix(11111)).toEqual('st');
+        expect(math.getNumberSuffix(1)).toBe('st');
+        expect(math.getNumberSuffix(11)).toBe('st');
+        expect(math.getNumberSuffix(11111)).toBe('st');
 
-        expect(math.getNumberSuffix(2)).toEqual('nd');
-        expect(math.getNumberSuffix(1232)).toEqual('nd');
-        expect(math.getNumberSuffix(32412.99)).toEqual('th');
+        expect(math.getNumberSuffix(2)).toBe('nd');
+        expect(math.getNumberSuffix(1232)).toBe('nd');
+        expect(math.getNumberSuffix(32412.99)).toBe('th');
 
-        expect(math.getNumberSuffix(3)).toEqual('rd');
-        expect(math.getNumberSuffix(323)).toEqual('rd');
-        expect(math.getNumberSuffix(1233.233)).toEqual('th');
+        expect(math.getNumberSuffix(3)).toBe('rd');
+        expect(math.getNumberSuffix(323)).toBe('rd');
+        expect(math.getNumberSuffix(1233.233)).toBe('th');
 
-        expect(math.getNumberSuffix(0)).toEqual('th');
-        expect(math.getNumberSuffix(145)).toEqual('th');
+        expect(math.getNumberSuffix(0)).toBe('th');
+        expect(math.getNumberSuffix(145)).toBe('th');
     });
 });

package/src/services/localization/defaultShape.ts

@@ -16,45 +16,11 @@ export const Strings = {
         PasswordsShouldMatch: 'Passwords should match',
         FirstName: 'First name is required',
         LastName: 'Last name is required',
-        Occupation: 'What\'s your client\'s job?',
-        Goal: 'Choose a goal to achieve',
         OnlyDigit: 'Only digits are valid',
         Website: 'Incorrect website',
         Linkedin: 'Incorrect Linkedin link',
     },
     UnknownServerError: 'Something went wrong and we were not able to process your request. Please contact the administrator.',
-    ClientStatuses: {
-        Active: 'Active',
-        Invited: 'Invited',
-        Inactive: 'Inactive',
-    },
-    BubbleChartStatus: {
-        Things: 'Things',
-        People: 'People',
-        Places: 'Places',
-    },
-    Locations: {
-        AtWork: 'At work',
-        OnAWalk: 'On a walk',
-        InThePark: 'At the park',
-        Somewhere: 'Somewhere else',
-        AtHome: 'At home',
-        InTransit: 'In transition',
-    },
-    Sentiments: {
-        Undefined: 'Unknown',
-        VeryPositive: 'Very Positive',
-        Positive: 'Positive',
-        Mixed: 'Mixed',
-        Difficult: 'Difficult',
-        Rough: 'Rough',
-    },
-    Periods: {
-        ThisWeek: 'this week',
-        Month: 'this month',
-        Months3: 'last 3 months',
-        Months6: 'last 6 months',
-    },
 };
 
 export type StringsShape = typeof Strings;

package/src/services/localization/validationErrorsStrings.ts

@@ -18,8 +18,6 @@ export default function Create(strings: StringsShape): ValidationErrorsStrings {
 
         [ValidationErrors.FirstName]: strings.Validation.FirstName,
         [ValidationErrors.LastName]: strings.Validation.LastName,
-        [ValidationErrors.Occupation]: strings.Validation.Occupation,
-        [ValidationErrors.Goal]: strings.Validation.Goal,
         [ValidationErrors.OnlyDigit]: strings.Validation.OnlyDigit,
         [ValidationErrors.Website]: strings.Validation.Website,
         [ValidationErrors.Linkedin]: strings.Validation.Linkedin,

package/src/validation/ValidationErrors.ts

@@ -17,8 +17,6 @@ export enum ValidationErrors {
     EmailIsInUse,
     FirstName,
     LastName,
-    Occupation,
-    Goal,
     Website,
     Linkedin,
 }

package/src/validation/validators.ts

@@ -32,8 +32,6 @@ export const Validators = {
 
     firstName: <T = string>(val: T) => val ? ValidationErrors.None : ValidationErrors.FirstName,
     lastName: <T = string>(val: T) => val ? ValidationErrors.None : ValidationErrors.LastName,
-    occupation: <T = string>(val: T) => val ? ValidationErrors.None : ValidationErrors.Occupation,
-    goal: <T = string>(val: T) => val ? ValidationErrors.None : ValidationErrors.Goal,
 
     fullName: (val: string) => ValidatorsRegExps.name.test(val.trim()) ? ValidationErrors.None : ValidationErrors.InvalidNameFormat,
     onlyEnglish: (val: string) => ValidatorsRegExps.englishLetters.test(val) ? ValidationErrors.None : ValidationErrors.OnlyEnglishLetters,