@zajno/common 1.5.9 → 1.6.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zajno/common",
-  "version": "1.5.9",
+  "version": "1.6.0",
   "description": "Zajno's re-usable utilities for JS/TS projects",
   "repository": {
     "type": "git",
@@ -25,25 +25,24 @@
     "rimraf": "^3"
   },
   "devDependencies": {
-    "@types/faker": "^5.5.9",
-    "@types/jest": "^28.1.6",
-    "@types/node": "^16.11.3",
-    "@zajno/eslint-config": "^2.1.0",
-    "eslint": "^8.20.0",
-    "faker": "^5.5.3",
-    "fast-check": "^2.18.0",
-    "jest": "^28.1.3",
-    "jest-extended": "^3.0.2",
-    "mobx": "^6.6.1",
-    "ts-jest": "^28.0.7",
+    "@faker-js/faker": "^7.5.0",
+    "@types/jest": "^29.0.3",
+    "@types/node": "^16.11.59",
+    "@zajno/eslint-config": "^2.2.0",
+    "eslint": "^8.23.1",
+    "fast-check": "^3.1.4",
+    "jest": "^29.0.3",
+    "jest-extended": "^3.1.0",
+    "mobx": "^6.6.2",
+    "ts-jest": "^29.0.1",
     "ts-node": "^10.9.1",
     "tslib": "^2.4.0",
-    "typescript": "^4.7.4"
+    "typescript": "^4.8.3"
   },
   "peerDependencies": {
-    "mobx": "^6",
-    "tslib": "^2",
-    "typescript": "^4"
+    "mobx": "^6.6",
+    "tslib": "^2.4",
+    "typescript": "^4.8"
   },
   "files": [
     "src/*",

package/src/__tests__/helpers/expect.ts

@@ -0,0 +1,3 @@
+import 'jest-extended';
+
+export const expectAnythingOrNothing = expect.toBeOneOf([expect.anything(), undefined, null]);

package/src/__tests__/helpers/main.ts

@@ -1,5 +1,5 @@
 import fc from 'fast-check';
-import faker from 'faker';
+import { faker } from '@faker-js/faker';
 
 export const toArbitrary = (fakerGen) => {
     return fc.integer()

package/src/lazy/__tests__/lazy.test.ts

@@ -0,0 +1,94 @@
+import { Lazy } from '../singleton';
+import { LazyPromise } from '../promise';
+import { setTimeoutAsync } from '../../async/timeout';
+
+import { LazyObservable, LazyPromiseObservable } from '../observable';
+import { reaction } from 'mobx';
+import { expectAnythingOrNothing } from '../../__tests__/helpers/expect';
+
+describe('Lazy', () => {
+    it('simple', () => {
+        const VAL = 'abc';
+        const l = new Lazy(() => VAL);
+
+        expect(l.hasValue).toBeFalse();
+        expect(l.value).toBe(VAL);
+        expect(l.hasValue).toBeTrue();
+
+        l.reset();
+        expect(l.hasValue).toBeFalse();
+
+        l.prewarm();
+
+        expect(l.hasValue).toBeTrue();
+        expect(l.value).toBe(VAL);
+    });
+
+    it('observable', () => {
+        const createObj = () => ({ str: 'abc' });
+        const l = new LazyObservable(() => createObj());
+
+        const listener = jest.fn().mockImplementation();
+
+        const clean = reaction(() => l.value, listener, { fireImmediately: true });
+
+        expect(listener).toHaveBeenCalledWith(createObj(), expectAnythingOrNothing, expectAnythingOrNothing);
+
+        listener.mockClear();
+
+        l.reset();
+
+        expect(listener).toHaveBeenCalledWith(createObj(), expectAnythingOrNothing, expectAnythingOrNothing);
+
+        clean();
+    });
+});
+
+describe('LazyPromise', () => {
+
+    it('simple', async () => {
+        const VAL = 'abc';
+        const l = new LazyPromise(() => setTimeoutAsync(100).then(() => VAL));
+
+        expect(l.hasValue).toBeFalse();
+        expect(l.busy).toBeFalse();
+
+        expect(l.value).toBeUndefined();
+        expect(l.busy).toBeTrue();
+
+        await expect(l.promise).resolves.not.toThrow();
+
+        expect(l.hasValue).toBeTrue();
+        expect(l.busy).toBeFalse();
+        expect(l.value).toBe(VAL);
+
+        l.dispose();
+        expect(l.hasValue).toBeFalse();
+    });
+
+    it('observable', async () => {
+        const VAL = 'abc';
+        const l = new LazyPromiseObservable(() => setTimeoutAsync(200).then(() => VAL));
+
+        expect(l.hasValue).toBeFalse();
+        expect(l.busy).toBeFalse();
+
+        expect(l.value).toBeUndefined();
+        expect(l.busy).toBeTrue();
+
+        const listener = jest.fn().mockImplementation();
+        const clean = reaction(() => l.value, listener, { fireImmediately: true });
+
+        expect(listener).toHaveBeenCalledWith(undefined, expectAnythingOrNothing, expectAnythingOrNothing);
+
+        await expect(l.promise).resolves.not.toThrow();
+
+        expect(listener).toHaveBeenCalledWith(VAL, expectAnythingOrNothing, expectAnythingOrNothing);
+
+        expect(l.hasValue).toBeTrue();
+        expect(l.busy).toBeFalse();
+        expect(l.value).toBe(VAL);
+
+        clean();
+    });
+});

package/src/lazy/index.ts

@@ -0,0 +1,33 @@
+
+import { LazyObservable, LazyPromiseObservable } from './observable';
+import logger from '../logger';
+
+// Backward compatibility stuff ...
+
+class LazyObservableWarned<T> extends LazyObservable<T> {
+
+    constructor(factory: () => T) {
+        super(factory);
+
+        logger.log('@zajno/common/lazy: you are using LazyObservable but imported just as Lazy. To avoid this warning import LazyObservable directly from lazy/observable or use non-observable version from lazy/singleton.');
+    }
+
+}
+
+class LazyPromiseObservableWarned<T> extends LazyPromiseObservable<T> {
+
+    constructor(factory: () => Promise<T>, initial?: T) {
+        super(factory, initial);
+
+        logger.log('@zajno/common/lazy: you are using LazyPromiseObservableWarned but imported just as LazyPromise. To avoid this warning import LazyPromiseObservable directly from lazy/observable or use non-observable version from lazy/promise.');
+    }
+
+}
+
+export default LazyObservableWarned;
+
+// In future versions make these imports straight
+export {
+    LazyObservableWarned as Lazy,
+    LazyPromiseObservableWarned as LazyPromise,
+};

package/src/lazy/light.ts

@@ -0,0 +1,29 @@
+import type { IDisposable } from '../disposer';
+
+export type LazyLight<T> = IDisposable & {
+    readonly value: T;
+    readonly hasValue: boolean;
+
+    reset(): void;
+};
+
+export function createLazy<T>(factory: () => T) {
+    const _factory = factory;
+    let _instance: T = undefined;
+
+    const res: LazyLight<T> = {
+        get value() {
+            if (_instance === undefined) {
+                _instance = _factory();
+            }
+            return _instance;
+        },
+        get hasValue() { return _instance !== undefined; },
+        reset: () => {
+            _instance = undefined;
+        },
+        dispose: () => res.reset(),
+    };
+
+    return res;
+}

package/src/lazy/observable.ts

@@ -0,0 +1,33 @@
+import { Lazy } from './singleton';
+import { LazyPromise } from './promise';
+import { observable, makeObservable, action } from 'mobx';
+
+export class LazyObservable<T> extends Lazy<T> {
+
+    constructor(factory: (() => T)) {
+        super(factory);
+
+        makeObservable<Lazy<T>, '_instance' | 'ensureInstance'>(this, {
+            _instance: observable,
+            reset: action,
+            ensureInstance: action,
+        });
+    }
+}
+
+export class LazyPromiseObservable<T> extends LazyPromise<T> {
+
+    constructor(
+        factory: () => Promise<T>,
+        initial?: T,
+    ) {
+        super(factory, initial);
+
+        makeObservable<LazyPromise<T>, '_instance' | '_busy' | 'setInstance'>(this, {
+            _instance: observable.ref,
+            _busy: observable,
+            setInstance: action,
+            reset: action,
+        });
+    }
+}

package/src/lazy/promise.ts

@@ -0,0 +1,48 @@
+import type { IDisposable } from '../disposer';
+
+export class LazyPromise<T> implements IDisposable {
+
+    private _instance: T = undefined;
+    private _busy: boolean = null;
+
+    private _promise: Promise<T> = null;
+
+    constructor(
+        private readonly _factory: () => Promise<T>,
+        private readonly initial: T = undefined,
+    ) {
+        this._instance = initial;
+    }
+
+    get busy() { return this._busy || false; }
+    get hasValue() { return this._busy === false; }
+
+    get promise() {
+        return this._promise;
+    }
+
+    get value() {
+        if (this._busy === null) {
+            this._busy = true;
+            this._promise = this._factory();
+            this._promise.then(this.setInstance);
+        }
+
+        return this._instance;
+    }
+
+    private setInstance = (res: T) => {
+        this._busy = false;
+        this._instance = res || null;
+
+        // keep this._promise to allow to re-use it outside
+    };
+
+    reset() {
+        this._busy = null;
+        this._instance = this.initial;
+        this._promise = null;
+    }
+
+    dispose = () => this.reset();
+}

package/src/lazy/singleton.ts

@@ -0,0 +1,32 @@
+import type { IDisposable } from '../disposer';
+
+export class Lazy<T> implements IDisposable {
+
+    protected _instance: T = null;
+
+    constructor(protected readonly _factory: (() => T)) { }
+
+    get hasValue() { return this._instance !== null; }
+
+    get value() {
+        this.ensureInstance();
+        return this._instance;
+    }
+
+    private ensureInstance() {
+        if (this._instance === null) {
+            this._instance = this._factory();
+        }
+    }
+
+    prewarm() {
+        this.ensureInstance();
+        return this;
+    }
+
+    reset() {
+        this._instance = null;
+    }
+
+    dispose() { this.reset(); }
+}

package/src/lazy.light.ts

@@ -1,29 +1,8 @@
-import type { IDisposable } from './disposer';
 
-export type LazyLight<T> = IDisposable & {
-    readonly value: T;
-    readonly hasValue: boolean;
+// DEPRECATED MODULE. Delete in future versions
 
-    reset(): void;
-};
+import logger from './logger';
 
-export function createLazy<T>(factory: () => T) {
-    const _factory = factory;
-    let _instance: T = undefined;
+export * from './lazy/light';
 
-    const res: LazyLight<T> = {
-        get value() {
-            if (_instance === undefined) {
-                _instance = _factory();
-            }
-            return _instance;
-        },
-        get hasValue() { return _instance !== undefined; },
-        reset: () => {
-            _instance = undefined;
-        },
-        dispose: () => res.reset(),
-    };
-
-    return res;
-}
+logger.warn('@zajno/common: importing module "lazy.light" is deprecated; please change your import to "lazy/light" module.');

package/src/logger/__tests__/logger.test.ts

@@ -1,4 +1,4 @@
-import faker from 'faker';
+import { faker } from '@faker-js/faker';
 import logger, { batchLoggers, createLogger, getMode, ILogger, setMode } from '..';
 import fc from 'fast-check';
 import { toArbitrary } from '../../__tests__/helpers/main';
@@ -9,16 +9,16 @@ const CONSOLE = console;
 describe('#logger-tests', () => {
 
   const customLogger = {
-    log: jest.fn().mockImplementation(null),
-    warn: jest.fn().mockImplementation(null),
-    error: jest.fn().mockImplementation(null),
+    log: jest.fn().mockImplementation(),
+    warn: jest.fn().mockImplementation(),
+    error: jest.fn().mockImplementation(),
   };
   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),
+    log: jest.spyOn(CONSOLE, 'log').mockImplementation(),
+    warn: jest.spyOn(CONSOLE, 'warn').mockImplementation(),
+    error: jest.spyOn(CONSOLE, 'error').mockImplementation(),
   } as const;
   const loggerMethods = Object.keys(consoleMocks) as (keyof ILogger)[];
 

package/src/queue/parallel.ts

@@ -17,6 +17,7 @@ export class ParallelQueue {
 
     private readonly _beforePriorityRun = new Event<number>();
     private readonly _afterPriorityRun = new Event<number>();
+    private readonly _finished = new Event();
 
     public get currentPriority() { return this._currentIndex; }
     public get inProgress() { return this._inProgress; }
@@ -24,6 +25,8 @@ export class ParallelQueue {
     public get beforePriorityRun() { return this._beforePriorityRun.expose(); }
     public get afterPriorityRun() { return this._afterPriorityRun.expose(); }
 
+    public get finished() { return this._finished.expose(); }
+
     public withLogger(name?: string) {
         this._logger = createLogger(`[Queue:${name || '?'}]`);
         return this;
@@ -120,6 +123,7 @@ export class ParallelQueue {
             // looks like we've finished!
             this._inProgress = false;
             this._logger?.log('Finished processing at index =', this._currentIndex);
+            this._finished.trigger();
             return;
         }
 

package/src/unsubscriber.ts

@@ -1,3 +1,6 @@
+
+// DEPRECATED MODULE. Delete in future versions
+
 import logger from './logger';
 
 export {

package/src/validation/__tests__/validator.test.ts

@@ -1,6 +1,6 @@
 import * as validation from '..';
 import { ValidationErrors } from '../ValidationErrors';
-import faker from 'faker';
+import { faker } from '@faker-js/faker';
 import fc from 'fast-check';
 import { toArbitrary } from '../../__tests__/helpers/main';
 

package/src/validation/validators.ts

@@ -4,7 +4,7 @@ import { ValidationErrors } from './ValidationErrors';
 export const ValidatorsRegExps = {
     // There is at least first and last name
     // eslint-disable-next-line no-useless-escape
-    name: /^[a-z,\.'-]+( +[a-z,\.'-]+)+$/i,
+    name: /^[\p{L},\.'-]+( +[\p{L},\.'-]+)+$/iu,
     englishLetters: /^([a-zA-Z\s]+)$/,
     email: /^([a-zA-Z0-9_.\-\\+])+@([a-zA-Z0-9_.-])+\.([a-zA-Z])+([a-zA-Z])+/,
 
@@ -22,7 +22,7 @@ export const ValidatorsRegExps = {
     expiryDateCard: /^\d+$/,
     cvv: /^\d+$/,
     // eslint-disable-next-line no-useless-escape
-    website: /^(https?:\/\/)?([a-z0-9]+((((-?[a-z0-9]{2,})+)?)\.))+[a-z]{2,}(:[0-9]{1,})?(\/.*)?$/i,
+    website: /^(https?:\/\/)?((\p{N}|\p{L})+((((-?(\p{N}|\p{L})+)+)?)\.))+\p{L}{2,}(:[0-9]+)?(\/.*)?$/iu,
     linkedin: /^(https?:\/\/)?([a-z]+\d*[a-z]*\.)?linkedin\.com\/.*$/i,
 };
 

package/src/viewModels/MultiSelectModel.ts

@@ -1,4 +1,4 @@
-import { createLazy } from '../lazy.light';
+import { createLazy } from '../lazy/light';
 import { action, computed, makeObservable, observable, reaction } from 'mobx';
 import { FlagModel, ILabeledFlagModel } from './FlagModel';
 import { ValidatableModel } from './Validatable';

package/src/viewModels/SelectModel.ts

@@ -1,5 +1,5 @@
 import { observable, computed, makeObservable, reaction, action } from 'mobx';
-import { createLazy } from '../lazy.light';
+import { createLazy } from '../lazy/light';
 import { FlagModel, ILabeledFlagModel } from './FlagModel';
 import { ValidatableModel } from './Validatable';
 import { IValueModel } from './types';