@zajno/common 1.6.3 → 2.0.0-beta.2

package/src/observingCache.ts

@@ -1,160 +0,0 @@
-import { action } from 'mobx';
-import { Disposable } from './disposer';
-import { PromiseCache, DeferredGetter } from './cache';
-import { ObserversMap } from './observersMap';
-import { Fields } from './fields';
-import logger from './logger';
-
-export type Unsub = () => void;
-export type Fetcher<T> = (key: string, cb: (val: T) => Promise<void> | void) => Unsub | Promise<Unsub>;
-
-type ObserveStrategy = boolean | 'short' | number;
-
-export interface IObservingCache<T> {
-    get(key: string): DeferredGetter<T>;
-}
-
-export class ObservingCache<T> extends Disposable implements IObservingCache<T> {
-
-    private readonly _cache: PromiseCache<T>;
-    private readonly _observers: ObserversMap;
-
-    private _observeStrategy: ObserveStrategy = null;
-    private readonly _observeStrategyOverrides: Record<string, ObserveStrategy> = { };
-
-    private _updater: Fields.Updater<T> = null;
-
-    constructor(readonly fetcher: Fetcher<T>) {
-        super();
-
-        this._cache = new PromiseCache(this._fetch);
-        this._observers = new ObserversMap(this._subscribe);
-
-        this.disposer.add(this._observers);
-    }
-
-    public get loadingCount() { return this._cache.busyCount; }
-    public get observersCount() { return this._observers.count; }
-
-    useObservingStrategy(observe: ObserveStrategy) {
-        this._observeStrategy = observe;
-        if (!this._observeStrategy) {
-            this._observers.clear();
-        } else {
-            const currentKeys = this._cache.keys();
-            const timeout = getObserveTimeout(this._observeStrategy);
-            currentKeys.forEach(key => this._observers.enable(key, true, timeout));
-        }
-
-        return this;
-    }
-
-    useUpdater(updater: Fields.Updater<T>) {
-        this._updater = updater;
-        this._cache.useObserveItems(updater != null);
-        return this;
-    }
-
-    getIsCached(key: string) {
-        return this._cache.hasKey(key);
-    }
-
-    getCurent(key: string) {
-        return this._cache.getCurrent(key, false);
-    }
-
-    get(key: string, overrideStrategy?: ObserveStrategy, observingStartedPromise?: (p: Promise<void>) => void): DeferredGetter<T> {
-        if (overrideStrategy !== undefined) {
-            this._observeStrategyOverrides[key] = overrideStrategy;
-        }
-
-        const strategy = firstDefined(this._observeStrategyOverrides[key], this._observeStrategy);
-
-        if (strategy && !this._observers.getIsObserving(key)) {
-            // ensure observe
-            if (this._cache.hasKey(key)) {
-                // the request has been initiated already
-                const timeout = getObserveTimeout(strategy);
-                const promise = this._observers.enable(key, true, timeout);
-                if (observingStartedPromise) {
-                    observingStartedPromise(promise);
-                }
-                promise.catch(err => logger.error('[ObservingCache] Error on starting observe', key, strategy, err));
-            }
-        }
-
-        return this._cache.getDeferred(key);
-    }
-
-    populate = (key: string, item: T) => {
-        this._updateItem(key, item);
-    };
-
-    invalidate = (key: string) => {
-        this._observers.enable(key, false);
-        this._cache.invalidate(key);
-    };
-
-    private _fetch = async (key: string): Promise<T> => {
-        let firstLoad = true;
-
-        return new Promise<T>((resolve) => {
-            Promise.resolve<Unsub>(
-                this.fetcher(key, item => {
-                    if (firstLoad) {
-                        resolve(item);
-                        firstLoad = false;
-                    } else {
-                        this._updateItem(key, item);
-                    }
-                })
-            ).then(unsub => {
-                const strategy = firstDefined(this._observeStrategyOverrides[key], this._observeStrategy);
-                if (!strategy) {
-                    // immediate unsub in case no observing strategy has been set
-                    unsub();
-                } else {
-                    const timeout = getObserveTimeout(strategy);
-                    this._observers.enable(key, true, timeout, [unsub]);
-                }
-            });
-        });
-    };
-
-    private _subscribe = (key: string) => {
-        return Promise.all([
-            this.fetcher(key, item => this._updateItem(key, item)),
-        ]);
-    };
-
-    private _updateItem = action((key: string, item: T) => {
-        if (this._updater != null && item != null) {
-            const current = this._cache.getCurrent(key, false);
-            if (current != null) {
-                const result = this._updater(current, item);
-                // re-set existing item but with updated contents
-                this._cache.updateValueDirectly(key, result);
-                return;
-            }
-        }
-
-        this._cache.updateValueDirectly(key, item);
-    });
-}
-
-function getObserveTimeout(s: ObserveStrategy) {
-    if (!s) {
-        return undefined;
-    }
-
-    return typeof s === 'number'
-        ? s
-        : (s === 'short'
-            ? 5 * 60 * 1000
-            : null
-        );
-}
-
-function firstDefined<T>(...values: (T | undefined)[]) {
-    return values.find(v => v !== undefined);
-}

package/src/services/localization/LocalaziedValidationErrors.ts

@@ -1,18 +0,0 @@
-import { action, observable } from 'mobx';
-import { IErrorsLocalization, ILocalizationDependency, ValidationErrorsFactory, ValidationErrorsStrings } from './abstractions';
-
-export class LocalaziedValidationErrors<TStrings extends { }, TErrors extends string | number>
-    implements IErrorsLocalization<TErrors>, ILocalizationDependency<TStrings> {
-
-    @observable.ref
-    private _strings: ValidationErrorsStrings<TErrors> = null;
-
-    constructor(private readonly factory: ValidationErrorsFactory<TStrings, TErrors>) { }
-
-    public get Errors(): Partial<Record<TErrors, string>> { return this._strings; }
-
-    @action
-    public updateLocale(strings: TStrings): void {
-        this._strings = this.factory(strings);
-    }
-}

package/src/services/localization/LocalizationManager.ts

@@ -1,53 +0,0 @@
-import { observable, makeObservable, action } from 'mobx';
-import { ILocalization, ILocalizationDependency } from './abstractions';
-
-export class LocalizationManager<TLocaleType extends string, TStrings extends { }> implements ILocalization<TStrings> {
-    @observable
-    private _currentLocale: TLocaleType = null;
-
-    @observable.ref
-    private _currentStrings: TStrings = null;
-
-    private readonly _defaultStrings: TStrings = null;
-    private readonly _dependants: ILocalizationDependency<TStrings, TLocaleType>[] = [];
-
-    constructor(
-        private readonly _dataSource: { [locale: string]: TStrings },
-        initialLocale: TLocaleType,
-        defaultLocale: TLocaleType = null,
-    ) {
-        makeObservable(this);
-        this._defaultStrings = this.getStrings(defaultLocale || initialLocale);
-        this.useLocale(initialLocale);
-    }
-
-    public get Locale() { return this._currentLocale; }
-    public get Current() { return this._currentStrings; }
-
-    @action
-    public useLocale(locale: TLocaleType) {
-        this._currentLocale = locale;
-        this._currentStrings = this.getStrings(this._currentLocale) || this._defaultStrings;
-        this.updateDependencies();
-        return this;
-    }
-
-    public useDependency(dep: ILocalizationDependency<TStrings, TLocaleType>, remove = false) {
-        const i = this._dependants.indexOf(dep);
-        if (i < 0 && !remove) {
-            this._dependants.push(dep);
-            this.updateDependencies();
-        } else if (i >= 0 && remove) {
-            this._dependants.splice(i, 1);
-        }
-        return this;
-    }
-
-    private updateDependencies() {
-        this._dependants.forEach(d => d.updateLocale(this._currentStrings, this._currentLocale));
-    }
-
-    private getStrings(locale: string): TStrings {
-        return this._dataSource[locale];
-    }
-}

package/src/services/localization/abstractions.ts

@@ -1,16 +0,0 @@
-
-export interface ILocalization<TStrings extends { }> {
-    readonly Current: Readonly<TStrings>;
-}
-
-export interface IErrorsLocalization<TErrors extends string | number> {
-    readonly Errors: ValidationErrorsStrings<TErrors>
-}
-
-export interface ILocalizationDependency<TStrings extends { }, TLocale extends string = any> {
-    updateLocale(strings: TStrings, locale?: TLocale): void;
-}
-
-export type ValidationErrorsStrings<T extends string | number> = Partial<Record<T, string>>;
-
-export type ValidationErrorsFactory<TStrings extends { }, TErrors extends string | number> = (strings: TStrings) => ValidationErrorsStrings<TErrors>;

package/src/services/localization/defaultShape.ts

@@ -1,26 +0,0 @@
-export const Strings = {
-    Ok: 'OK',
-    Cancel: 'Cancel',
-    Submit: 'Submit',
-    ForgotPassword: 'Forgot password?',
-    Validation: {
-        Empty: 'Value should be not empty',
-        Name: 'Invalid name format',
-        Email: 'Incorrect email',
-        Password: 'Must include at least 8 characters',
-        EnglishOnly: 'Only English letters supported',
-        Phone: 'Invalid phone number format: only digits allowed',
-        CreditCard: 'Invalid credit card number format',
-        CreditCardExpiryDate: 'Invalid expiry date format',
-        CreditCardCvv: 'Invalid CVV format',
-        PasswordsShouldMatch: 'Passwords should match',
-        FirstName: 'First name is required',
-        LastName: 'Last name is required',
-        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.',
-};
-
-export type StringsShape = typeof Strings;

package/src/services/localization/index.ts

@@ -1,6 +0,0 @@
-import { LocalizationManager } from './LocalizationManager';
-import { LocalaziedValidationErrors } from './LocalaziedValidationErrors';
-
-export * from './abstractions';
-
-export { LocalizationManager, LocalaziedValidationErrors };

package/src/services/storage/web/localStorage.ts

@@ -1,35 +0,0 @@
-import { KeyStorage, KeyStorageConverted, StorageAsyncWrapper } from '..';
-import IStorage, { IStorageSync } from '../../../abstractions/services/storage';
-import { WebStorage } from './webStorage';
-
-/* global window */
-
-if (typeof window === 'undefined') {
-    throw new Error("Can't use web/Storage module outside browser environment!");
-}
-
-class WebLocalStorage extends WebStorage {
-    protected get storage() { return window.localStorage; }
-}
-
-export const LocalStorage: IStorageSync = new WebLocalStorage();
-
-export const LocalStorageAsync: IStorage = new StorageAsyncWrapper(LocalStorage);
-
-export class LocalKeyStorage extends KeyStorage {
-    constructor(readonly key: string) {
-        super(LocalStorage, key);
-    }
-}
-
-export class LocalKeyStorageConverted<T> extends KeyStorageConverted<T> {
-    constructor(
-        key: string,
-        input?: (v: T) => string,
-        output?: (s: string) => T,
-    ) {
-        super(LocalStorage, key, input, output);
-    }
-}
-
-export default LocalStorage;

package/src/services/storage/web/sessionStorage.ts

@@ -1,35 +0,0 @@
-import { KeyStorage, KeyStorageConverted, StorageAsyncWrapper } from '..';
-import IStorage, { IStorageSync } from '../../../abstractions/services/storage';
-import { WebStorage } from './webStorage';
-
-/* global window */
-
-if (typeof window === 'undefined') {
-    throw new Error("Can't use web/Storage module outside browser environment!");
-}
-
-class WebSessionStorage extends WebStorage {
-    protected get storage() { return window.sessionStorage; }
-}
-
-export const SessionStorage: IStorageSync = new WebSessionStorage();
-
-export const SessionStorageAsync: IStorage = new StorageAsyncWrapper(SessionStorage);
-
-export class SessionKeyStorage extends KeyStorage {
-    constructor(readonly key: string) {
-        super(SessionStorage, key);
-    }
-}
-
-export class SessionKeyStorageConverted<T> extends KeyStorageConverted<T> {
-    constructor(
-        key: string,
-        input?: (v: T) => string,
-        output?: (s: string) => T,
-    ) {
-        super(SessionStorage, key, input, output);
-    }
-}
-
-export default SessionStorage;

package/src/services/storage/web/webStorage.ts

@@ -1,29 +0,0 @@
-
-import { IStorageSync } from '../../../abstractions/services/storage';
-
-export abstract class WebStorage implements IStorageSync {
-
-    protected abstract get storage(): Storage;
-
-    getValue(key: string) {
-        return this.storage.getItem(key);
-    }
-
-    setValue(key: string, value: string) {
-        this.storage.setItem(key, value);
-    }
-
-    hasValue(key: string) {
-        return this.storage.getItem(key) != null;
-    }
-
-    removeValue(key: string) {
-        const hasValue = this.hasValue(key);
-        if (!hasValue) {
-            return false;
-        }
-
-        this.storage.removeItem(key);
-        return true;
-    }
-}

package/src/timeHelper.ts

@@ -1,39 +0,0 @@
-
-// eslint-disable-next-line no-console
-console.warn('"timeHelper" module is deprecated. Please use "dates" one.');
-
-/** @deprecated */
-export function formatMS(ms: number): string {
-    if (!ms && ms !== 0) {
-        return '';
-    }
-
-    const sec = Math.floor((ms / 1000) % 60);
-    const min = Math.floor((ms / (1000 * 60)) % 60);
-    const hours = Math.floor((ms / (1000 * 60 * 60)) % 60);
-
-    return `${hours ? hours + ':' : ''}${min < 10 ? '0' + min : min}:${sec < 10 ? '0' + sec : sec}`;
-}
-
-/** @deprecated */
-export function formatTime(n: number): string {
-    if (n < 10) {
-        return '0' + n;
-    }
-
-    return n.toString();
-}
-
-/** @deprecated */
-export function secToFormattedMin(totalSec: number): string {
-    const sec = Math.round(totalSec) % 60;
-    const min = Math.floor((totalSec + 1) / 60);
-    let res = `${formatTime(min)}`;
-
-    if (sec) {
-        res += ':';
-        res += formatTime(Math.floor(sec));
-    }
-
-    return res;
-}

package/src/transitionObserver.ts

@@ -1,183 +0,0 @@
-import { reaction } from 'mobx';
-import { IEvent, Event } from './event';
-import { ILogger, createLogger } from './logger';
-import { IDisposable } from './disposer';
-
-export class TransitionObserver<T> implements IDisposable {
-
-    private readonly _event = new Event<T>();
-    private _getter: () => T = null;
-
-    private _disposer: () => void;
-    private _prev: T = undefined;
-
-    private _from: T = undefined;
-    private _to: T = undefined;
-
-    private _cb: (v: T) => any;
-    private _fireOnce = false;
-
-    private _promise: Promise<T> = null;
-    private _promiseReject: (err?: any) => any = null;
-
-    private logger: ILogger = createLogger('', false);
-
-    constructor(getter?: () => T) {
-        if (getter) {
-            this.observe(getter);
-        }
-    }
-
-    public get event(): IEvent<T> { return this._event; }
-    public get currentValue() { return this._prev; }
-
-    public get isObserving() { return this._disposer != null; }
-    private get isPromising() { return this._promiseReject != null; }
-
-    observe(getter: () => T) {
-        this.dispose();
-        this._getter = getter;
-        this._prev = this._getter();
-        this._disposer = reaction(this._getter, this._checkValue);
-        return this;
-    }
-
-    from(from: T) {
-        this._from = from;
-        return this;
-    }
-
-    to(to: T) {
-        this._to = to;
-        return this;
-    }
-
-    cb(cb: (v: T) => any) {
-        if (this.isPromising) {
-            throw new Error('Cannot set callback when promise is running');
-        }
-        this._cb = cb;
-        return this;
-    }
-
-    forceCall() {
-        if (this._cb) {
-            this._cb(this._prev);
-        }
-        return this;
-    }
-
-    fireOnce(enable = true) {
-        this._fireOnce = enable;
-        return this;
-    }
-
-    forceCheck() {
-        return this._checkValue(this._getter());
-    }
-
-    andForceCheck() {
-        this.forceCheck();
-        return this;
-    }
-
-    getPromise(timeout: number = null) {
-        if (!this._promise) {
-            if (!this.isObserving) {
-                return Promise.reject(new Error('Cannot get promise for disposed TransitionObserver'));
-            }
-
-            this._promise = new Promise<T>((resolve, reject) => {
-                this._promiseReject = reject;
-
-                let timeoutHandle: any = null;
-                if (timeout) {
-                    timeoutHandle = setTimeout(() => {
-                        this._finishPromise(this._promiseReject, new Error(`TransitionObserver Aborted – timed out after ${timeout}ms`));
-                    }, timeout);
-                }
-
-                this._cb = (v => {
-                    clearTimeout(timeoutHandle);
-                    this._finishPromise(resolve, v);
-                });
-                this.forceCheck();
-            });
-            this.logger.log('started a new promise...');
-        }
-        return this._promise;
-    }
-
-    reverse() {
-        return new TransitionObserver<T>(this._getter)
-            .from(this._to)
-            .to(this._from);
-    }
-
-    enableLogging(name: string) {
-        this.logger = createLogger(name, name ? undefined : false);
-        return this;
-    }
-
-    dispose = () => {
-        this.logger.log(' disposing... ');
-        if (this._disposer) {
-            this._disposer();
-            this._disposer = null;
-        }
-        if (this.isPromising) {
-            this._finishPromise(this._promiseReject, new Error('TransitionObserver Aborted'));
-        }
-    };
-
-    private _checkValue = (v: T) => {
-        let trigger = false;
-
-        if (this._from !== undefined && this._to !== undefined) {
-            // both 'from' and 'two' should be matched
-            trigger = this._prev === this._from && v === this._to;
-        } else if (this._from !== undefined || this._to !== undefined) {
-            // at least one match – 'from' or 'to'
-            trigger = (this._from !== undefined && this._from === this._prev)
-                || (this._to !== undefined && this._to === v);
-        } else {
-            // if both 'from' and 'to' are undefined – trigger for any change
-            // this._from === undefined && this._to === undefined;
-            trigger = true;
-        }
-
-        this.logger.log('Checked value:', v, ' ==> will trigger:', trigger);
-
-        this._prev = v;
-
-        if (trigger) {
-            this._event.trigger(v);
-
-            if (this._cb) {
-                this._cb(v);
-            }
-
-            if (this._fireOnce) {
-                this.dispose();
-            }
-        }
-
-        return trigger;
-    };
-
-    private _finishPromise<T>(cb: (a?: T) => any, arg?: T) {
-        this._promise = null;
-        this._promiseReject = null;
-        this._cb = null;
-        if (cb) {
-            cb(arg);
-        }
-    }
-}
-
-export function waitFor<T>(current: () => T, toBe: T) {
-    return new TransitionObserver(current)
-        .to(toBe)
-        .fireOnce()
-        .getPromise();
-}

package/src/types.ts

@@ -1,30 +0,0 @@
-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;
-}
-
-export type TypedKeys<T extends Object, K> = {
-    [P in keyof T]: T[P] extends K ? P : never
-}[keyof T];

package/src/unsubscriber.ts

@@ -1,14 +0,0 @@
-
-// DEPRECATED MODULE. Delete in future versions
-
-import logger from './logger';
-
-export {
-    IDisposable,
-    DisposeFunction as Disposer,
-    combineDisposers,
-    Disposer as Unsubscriber,
-    Disposable,
-} from './disposer';
-
-logger.warn('@zajno/common: importing module "unsusbcriber" is deprecated; please change your import to "disposer" module.');

package/src/validation/ValidationErrorsLocalization.ts

@@ -1,27 +0,0 @@
-import { ValidationErrorsStrings } from '../services/localization';
-import { StringsShape } from '../services/localization/defaultShape';
-import { LocalaziedValidationErrors } from '../services/localization/LocalaziedValidationErrors';
-import { ValidationErrors } from './ValidationErrors';
-
-function locationFactory(strings: StringsShape): ValidationErrorsStrings<ValidationErrors> {
-    return {
-        [ValidationErrors.None]: '',
-        [ValidationErrors.ShouldBeNonEmpty]: strings.Validation.Empty,
-        [ValidationErrors.InvalidNameFormat]: strings.Validation.Name,
-        [ValidationErrors.InvalidEmailFormat]: strings.Validation.Email,
-        [ValidationErrors.InvalidPasswordFormat]: strings.Validation.Password,
-        [ValidationErrors.OnlyEnglishLetters]: strings.Validation.EnglishOnly,
-        [ValidationErrors.InvalidPhoneFormat]: strings.Validation.Phone,
-        [ValidationErrors.InvalidCreditCardFormat]: strings.Validation.CreditCard,
-        [ValidationErrors.InvalidCreditCardExpiryDateFormat]: strings.Validation.CreditCardExpiryDate,
-        [ValidationErrors.InvalidCreditCardCvvFormat]: strings.Validation.CreditCardCvv,
-
-        [ValidationErrors.FirstName]: strings.Validation.FirstName,
-        [ValidationErrors.LastName]: strings.Validation.LastName,
-        [ValidationErrors.OnlyDigit]: strings.Validation.OnlyDigit,
-        [ValidationErrors.Website]: strings.Validation.Website,
-        [ValidationErrors.Linkedin]: strings.Validation.Linkedin,
-    };
-}
-
-export const ValidationErrorsLocalized = new LocalaziedValidationErrors<StringsShape, ValidationErrors>(locationFactory);