@bravobit/bb-foundation 0.26.2 → 0.27.0

package/esm2022/lib/core/services/languages.service.mjs

@@ -0,0 +1,75 @@
+import { ACCEPT_LANGUAGE } from '../tokens/accept-language.token';
+import { Inject, Injectable, Optional } from '@angular/core';
+import * as i0 from "@angular/core";
+class Languages {
+    constructor(_acceptLanguage) {
+        this._acceptLanguage = _acceptLanguage;
+        // Data.
+        this._data = [];
+        this.getLanguages = () => {
+            // If defined we must be in a server environment.
+            if (this._acceptLanguage) {
+                return this._acceptLanguage;
+            }
+            // Try to get the languages from the navigator.
+            if (typeof navigator !== 'object') {
+                return null;
+            }
+            let t = 'anguage';
+            let n = navigator;
+            let f = n['l' + t + 's'];
+            const data = f && f.length ? f : (t = n['l' + t] ||
+                n['browserL' + t] ||
+                n['userL' + t]) ? [t] : t;
+            return typeof data === 'string'
+                ? data
+                : data.join(';');
+        };
+        this._data = this.initialize();
+    }
+    get all() {
+        return this._data;
+    }
+    initialize() {
+        // Get the languages.
+        const data = this.getLanguages();
+        // Parse all languages by using a regex.
+        const strings = (data || '')
+            .match(/((([a-zA-Z]+(-[a-zA-Z0-9]+){0,2})|\*)(;q=[0-1](\.[0-9]+)?)?)*/g);
+        // Get the content by parsing the strings.
+        const content = strings.map(item => {
+            if (!item) {
+                return null;
+            }
+            const bits = item.split(';');
+            const ietf = bits[0].split('-');
+            const hasScript = ietf.length === 3;
+            return {
+                code: ietf[0],
+                script: hasScript ? ietf[1] : null,
+                region: hasScript ? ietf[2] : ietf[1],
+                quality: bits[1] ? parseFloat(bits[1].split('=')[1]) : 1.0
+            };
+        });
+        // Filter out all the empty items
+        // and sort them by the quality.
+        return content
+            .filter(item => !!item)
+            .sort((a, b) => b.quality - a.quality);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: Languages, deps: [{ token: ACCEPT_LANGUAGE, optional: true }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: Languages, providedIn: 'root' }); }
+}
+export { Languages };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: Languages, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [ACCEPT_LANGUAGE]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/core/services/network.service.mjs

@@ -0,0 +1,56 @@
+import { distinctUntilChanged, map, shareReplay } from 'rxjs/operators';
+import { Inject, Injectable, Optional } from '@angular/core';
+import { fromEvent, merge, Observable, of } from 'rxjs';
+import { NAVIGATOR } from '../tokens/navigator.token';
+import { WINDOW } from '../tokens/window.token';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/cdk/platform";
+class Network {
+    constructor(_platform, _window, _navigator) {
+        this._platform = _platform;
+        this._window = _window;
+        this._navigator = _navigator;
+        // Data.
+        this._online$ = of(true);
+        this.getOnlineObservable();
+    }
+    online() {
+        return this._online$;
+    }
+    getOnlineObservable() {
+        // Validate we are on a browser.
+        if (!this._platform.isBrowser) {
+            return;
+        }
+        // Get all the events from the window.
+        const online$ = fromEvent(this._window, 'online').pipe(map(() => true));
+        const offline$ = fromEvent(this._window, 'offline').pipe(map(() => false));
+        const now$ = new Observable(subscriber => {
+            subscriber.next(this._navigator?.onLine);
+            subscriber.complete();
+        });
+        // Merge all event so we get notified when
+        // a user is online/offline.
+        this._online$ = merge(now$, online$, offline$).pipe(map(value => value), distinctUntilChanged(), shareReplay({ refCount: true, bufferSize: 1 }));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: Network, deps: [{ token: i1.Platform }, { token: WINDOW, optional: true }, { token: NAVIGATOR, optional: true }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: Network, providedIn: 'root' }); }
+}
+export { Network };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: Network, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.Platform }, { type: Window, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [WINDOW]
+                }] }, { type: Navigator, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [NAVIGATOR]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibmV0d29yay5zZXJ2aWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvYmItZm91bmRhdGlvbi9zcmMvbGliL2NvcmUvc2VydmljZXMvbmV0d29yay5zZXJ2aWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBQyxvQkFBb0IsRUFBRSxHQUFHLEVBQUUsV0FBVyxFQUFDLE1BQU0sZ0JBQWdCLENBQUM7QUFDdEUsT0FBTyxFQUFDLE1BQU0sRUFBRSxVQUFVLEVBQUUsUUFBUSxFQUFDLE1BQU0sZUFBZSxDQUFDO0FBQzNELE9BQU8sRUFBQyxTQUFTLEVBQUUsS0FBSyxFQUFFLFVBQVUsRUFBRSxFQUFFLEVBQUMsTUFBTSxNQUFNLENBQUM7QUFDdEQsT0FBTyxFQUFDLFNBQVMsRUFBQyxNQUFNLDJCQUEyQixDQUFDO0FBRXBELE9BQU8sRUFBQyxNQUFNLEVBQUMsTUFBTSx3QkFBd0IsQ0FBQzs7O0FBRTlDLE1BR2EsT0FBTztJQUtoQixZQUFvQixTQUFtQixFQUNTLE9BQWdCLEVBQ2IsVUFBc0I7UUFGckQsY0FBUyxHQUFULFNBQVMsQ0FBVTtRQUNTLFlBQU8sR0FBUCxPQUFPLENBQVM7UUFDYixlQUFVLEdBQVYsVUFBVSxDQUFZO1FBTHpFLFFBQVE7UUFDQSxhQUFRLEdBQXdCLEVBQUUsQ0FBQyxJQUFJLENBQUMsQ0FBQztRQUs3QyxJQUFJLENBQUMsbUJBQW1CLEVBQUUsQ0FBQztJQUMvQixDQUFDO0lBRUQsTUFBTTtRQUNGLE9BQU8sSUFBSSxDQUFDLFFBQVEsQ0FBQztJQUN6QixDQUFDO0lBRU8sbUJBQW1CO1FBQ3ZCLGdDQUFnQztRQUNoQyxJQUFJLENBQUMsSUFBSSxDQUFDLFNBQVMsQ0FBQyxTQUFTLEVBQUU7WUFDM0IsT0FBTztTQUNWO1FBRUQsc0NBQXNDO1FBQ3RDLE1BQU0sT0FBTyxHQUFHLFNBQVMsQ0FBQyxJQUFJLENBQUMsT0FBTyxFQUFFLFFBQVEsQ0FBQyxDQUFDLElBQUksQ0FBQyxHQUFHLENBQUMsR0FBRyxFQUFFLENBQUMsSUFBSSxDQUFDLENBQUMsQ0FBQztRQUN4RSxNQUFNLFFBQVEsR0FBRyxTQUFTLENBQUMsSUFBSSxDQUFDLE9BQU8sRUFBRSxTQUFTLENBQUMsQ0FBQyxJQUFJLENBQUMsR0FBRyxDQUFDLEdBQUcsRUFBRSxDQUFDLEtBQUssQ0FBQyxDQUFDLENBQUM7UUFDM0UsTUFBTSxJQUFJLEdBQUcsSUFBSSxVQUFVLENBQUMsVUFBVSxDQUFDLEVBQUU7WUFDckMsVUFBVSxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsVUFBVSxFQUFFLE1BQU0sQ0FBQyxDQUFDO1lBQ3pDLFVBQVUsQ0FBQyxRQUFRLEVBQUUsQ0FBQztRQUMxQixDQUFDLENBQUMsQ0FBQztRQUVILDBDQUEwQztRQUMxQyw0QkFBNEI7UUFDNUIsSUFBSSxDQUFDLFFBQVEsR0FBRyxLQUFLLENBQUMsSUFBSSxFQUFFLE9BQU8sRUFBRSxRQUFRLENBQUMsQ0FBQyxJQUFJLENBQy9DLEdBQUcsQ0FBQyxLQUFLLENBQUMsRUFBRSxDQUFDLEtBQWdCLENBQUMsRUFDOUIsb0JBQW9CLEVBQUUsRUFDdEIsV0FBVyxDQUFDLEVBQUMsUUFBUSxFQUFFLElBQUksRUFBRSxVQUFVLEVBQUUsQ0FBQyxFQUFDLENBQUMsQ0FDL0MsQ0FBQztJQUNOLENBQUM7OEdBcENRLE9BQU8sMENBTWdCLE1BQU0sNkJBQ04sU0FBUztrSEFQaEMsT0FBTyxjQUZKLE1BQU07O1NBRVQsT0FBTzsyRkFBUCxPQUFPO2tCQUhuQixVQUFVO21CQUFDO29CQUNSLFVBQVUsRUFBRSxNQUFNO2lCQUNyQjs7MEJBT2dCLFFBQVE7OzBCQUFJLE1BQU07MkJBQUMsTUFBTTs7MEJBQ3pCLFFBQVE7OzBCQUFJLE1BQU07MkJBQUMsU0FBUyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7ZGlzdGluY3RVbnRpbENoYW5nZWQsIG1hcCwgc2hhcmVSZXBsYXl9IGZyb20gJ3J4anMvb3BlcmF0b3JzJztcbmltcG9ydCB7SW5qZWN0LCBJbmplY3RhYmxlLCBPcHRpb25hbH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQge2Zyb21FdmVudCwgbWVyZ2UsIE9ic2VydmFibGUsIG9mfSBmcm9tICdyeGpzJztcbmltcG9ydCB7TkFWSUdBVE9SfSBmcm9tICcuLi90b2tlbnMvbmF2aWdhdG9yLnRva2VuJztcbmltcG9ydCB7UGxhdGZvcm19IGZyb20gJ0Bhbmd1bGFyL2Nkay9wbGF0Zm9ybSc7XG5pbXBvcnQge1dJTkRPV30gZnJvbSAnLi4vdG9rZW5zL3dpbmRvdy50b2tlbic7XG5cbkBJbmplY3RhYmxlKHtcbiAgICBwcm92aWRlZEluOiAncm9vdCdcbn0pXG5leHBvcnQgY2xhc3MgTmV0d29yayB7XG5cbiAgICAvLyBEYXRhLlxuICAgIHByaXZhdGUgX29ubGluZSQ6IE9ic2VydmFibGU8Ym9vbGVhbj4gPSBvZih0cnVlKTtcblxuICAgIGNvbnN0cnVjdG9yKHByaXZhdGUgX3BsYXRmb3JtOiBQbGF0Zm9ybSxcbiAgICAgICAgICAgICAgICBAT3B0aW9uYWwoKSBASW5qZWN0KFdJTkRPVykgcHJpdmF0ZSBfd2luZG93PzogV2luZG93LFxuICAgICAgICAgICAgICAgIEBPcHRpb25hbCgpIEBJbmplY3QoTkFWSUdBVE9SKSBwcml2YXRlIF9uYXZpZ2F0b3I/OiBOYXZpZ2F0b3IpIHtcbiAgICAgICAgdGhpcy5nZXRPbmxpbmVPYnNlcnZhYmxlKCk7XG4gICAgfVxuXG4gICAgb25saW5lKCkge1xuICAgICAgICByZXR1cm4gdGhpcy5fb25saW5lJDtcbiAgICB9XG5cbiAgICBwcml2YXRlIGdldE9ubGluZU9ic2VydmFibGUoKSB7XG4gICAgICAgIC8vIFZhbGlkYXRlIHdlIGFyZSBvbiBhIGJyb3dzZXIuXG4gICAgICAgIGlmICghdGhpcy5fcGxhdGZvcm0uaXNCcm93c2VyKSB7XG4gICAgICAgICAgICByZXR1cm47XG4gICAgICAgIH1cblxuICAgICAgICAvLyBHZXQgYWxsIHRoZSBldmVudHMgZnJvbSB0aGUgd2luZG93LlxuICAgICAgICBjb25zdCBvbmxpbmUkID0gZnJvbUV2ZW50KHRoaXMuX3dpbmRvdywgJ29ubGluZScpLnBpcGUobWFwKCgpID0+IHRydWUpKTtcbiAgICAgICAgY29uc3Qgb2ZmbGluZSQgPSBmcm9tRXZlbnQodGhpcy5fd2luZG93LCAnb2ZmbGluZScpLnBpcGUobWFwKCgpID0+IGZhbHNlKSk7XG4gICAgICAgIGNvbnN0IG5vdyQgPSBuZXcgT2JzZXJ2YWJsZShzdWJzY3JpYmVyID0+IHtcbiAgICAgICAgICAgIHN1YnNjcmliZXIubmV4dCh0aGlzLl9uYXZpZ2F0b3I/Lm9uTGluZSk7XG4gICAgICAgICAgICBzdWJzY3JpYmVyLmNvbXBsZXRlKCk7XG4gICAgICAgIH0pO1xuXG4gICAgICAgIC8vIE1lcmdlIGFsbCBldmVudCBzbyB3ZSBnZXQgbm90aWZpZWQgd2hlblxuICAgICAgICAvLyBhIHVzZXIgaXMgb25saW5lL29mZmxpbmUuXG4gICAgICAgIHRoaXMuX29ubGluZSQgPSBtZXJnZShub3ckLCBvbmxpbmUkLCBvZmZsaW5lJCkucGlwZShcbiAgICAgICAgICAgIG1hcCh2YWx1ZSA9PiB2YWx1ZSBhcyBib29sZWFuKSxcbiAgICAgICAgICAgIGRpc3RpbmN0VW50aWxDaGFuZ2VkKCksXG4gICAgICAgICAgICBzaGFyZVJlcGxheSh7cmVmQ291bnQ6IHRydWUsIGJ1ZmZlclNpemU6IDF9KVxuICAgICAgICApO1xuICAgIH1cblxufVxuIl19

package/esm2022/lib/core/services/patch.service.mjs

@@ -0,0 +1,64 @@
+import { Inject, Injectable, Optional } from '@angular/core';
+import { debounceTime, startWith } from 'rxjs/operators';
+import { WINDOW } from '../tokens/window.token';
+import { fromEvent, Subscription } from 'rxjs';
+import { DOCUMENT } from '@angular/common';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/cdk/platform";
+class Patch {
+    constructor(_platform, _window, _document) {
+        this._platform = _platform;
+        this._window = _window;
+        this._document = _document;
+        this._hasPatchedMobileVerticalHeight = false;
+        // Subscriptions.
+        this._subscription = new Subscription();
+    }
+    mobileVerticalHeight() {
+        // Check if the user has already patched
+        // the mobile vertical height.
+        if (this._hasPatchedMobileVerticalHeight) {
+            return;
+        }
+        this.periodicallySetDocumentVerticalProperty();
+        this._hasPatchedMobileVerticalHeight = true;
+    }
+    ngOnDestroy() {
+        this._subscription?.unsubscribe();
+    }
+    periodicallySetDocumentVerticalProperty() {
+        // Validate we are using a browser.
+        if (!this._platform.isBrowser) {
+            return;
+        }
+        // Listen to a debounced window resize event.
+        const resize$ = fromEvent(this._window, 'resize').pipe(debounceTime(25), startWith(0));
+        // Subscribe to the resize observable.
+        const subscription = resize$.subscribe(() => {
+            const verticalHeight = this._window?.innerHeight * 0.01;
+            this._document?.documentElement?.style?.setProperty('--vh', `${verticalHeight}px`);
+        });
+        // Save the subscription so we can destroy it later.
+        this._subscription.add(subscription);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: Patch, deps: [{ token: i1.Platform }, { token: WINDOW, optional: true }, { token: DOCUMENT, optional: true }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: Patch, providedIn: 'root' }); }
+}
+export { Patch };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: Patch, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.Platform }, { type: Window, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [WINDOW]
+                }] }, { type: Document, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [DOCUMENT]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/localize/lib/localize.module.mjs

@@ -0,0 +1,82 @@
+import { APP_INITIALIZER, LOCALE_ID, NgModule } from '@angular/core';
+import { BbLocalizeString } from './views/localize-string/localize-string.component';
+import { LocalizeInterpolateTransform } from './transforms/interpolate.transform';
+import { LocalizeReferenceTransform } from './transforms/reference.transform';
+import { LocalizeLowercaseFunction } from './functions/lowercase.function';
+import { LocalizeUppercaseFunction } from './functions/uppercase.function';
+import { BbLocalizeTemplate } from './views/localize-template.directive';
+import { LOCALIZE_TRANSFORM } from './interfaces/transforms.interfaces';
+import { LOCALIZE_FUNCTION } from './interfaces/functions.interfaces';
+import { LocalizeMissingHandler } from './handlers/missing.handler';
+import { LocalizeDateFunction } from './functions/date.function';
+import { LocalizeConfig } from './interfaces/config.interfaces';
+import { UtilsModule } from '@bravobit/bb-foundation/utils';
+import { CommonModule } from '@angular/common';
+import { Localize } from './localize.service';
+import { BbLocalize } from './localize.pipe';
+import * as i0 from "@angular/core";
+class LocalizeModule {
+    static forRoot(config) {
+        if (config?.languages?.length <= 0) {
+            throw new Error('One or more languages should be supplied.');
+        }
+        if (config?.compareDictionaries && config?.mode === 'manual') {
+            console?.warn?.('You cannot enable "compareDictionaries" when having mode set to "manual"; This setting will be ignored.');
+        }
+        const mode = config?.mode ?? 'automatic';
+        return {
+            ngModule: LocalizeModule,
+            providers: [
+                // Angular providers.
+                ...(mode === 'automatic' ? [
+                    { provide: APP_INITIALIZER, deps: [Localize], useFactory: initializeLocale, multi: true },
+                    { provide: LOCALE_ID, deps: [Localize], useFactory: getLocale }
+                ] : []),
+                // Config provider.
+                { provide: LocalizeConfig, useValue: config },
+                // Function providers.
+                { provide: LOCALIZE_FUNCTION, useClass: LocalizeLowercaseFunction, multi: true },
+                { provide: LOCALIZE_FUNCTION, useClass: LocalizeUppercaseFunction, multi: true },
+                { provide: LOCALIZE_FUNCTION, useClass: LocalizeDateFunction, multi: true },
+                // Transform providers.
+                { provide: LOCALIZE_TRANSFORM, useClass: LocalizeReferenceTransform, deps: [LocalizeConfig], multi: true },
+                { provide: LOCALIZE_TRANSFORM, useClass: LocalizeInterpolateTransform, deps: [LocalizeConfig, LOCALIZE_FUNCTION], multi: true },
+                // Handler providers.
+                { provide: LocalizeMissingHandler, useClass: LocalizeMissingHandler },
+                // Service providers.
+                Localize
+            ]
+        };
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: LocalizeModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "16.0.0", ngImport: i0, type: LocalizeModule, declarations: [BbLocalize,
+            BbLocalizeString,
+            BbLocalizeTemplate], imports: [CommonModule, UtilsModule], exports: [BbLocalize,
+            BbLocalizeString,
+            BbLocalizeTemplate] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: LocalizeModule, imports: [CommonModule, UtilsModule] }); }
+}
+export { LocalizeModule };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: LocalizeModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [CommonModule, UtilsModule],
+                    declarations: [
+                        BbLocalize,
+                        BbLocalizeString,
+                        BbLocalizeTemplate
+                    ],
+                    exports: [
+                        BbLocalize,
+                        BbLocalizeString,
+                        BbLocalizeTemplate
+                    ]
+                }]
+        }] });
+export function initializeLocale(localize) {
+    return localize.initialize();
+}
+export function getLocale(localize) {
+    return localize?.current?.locale ?? null;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"localize.module.js","sourceRoot":"","sources":["../../../../../projects/bb-foundation/localize/src/lib/localize.module.ts"],"names":[],"mappings":"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","sourcesContent":["import {APP_INITIALIZER, LOCALE_ID, ModuleWithProviders, NgModule} from '@angular/core';\nimport {BbLocalizeString} from './views/localize-string/localize-string.component';\nimport {LocalizeInterpolateTransform} from './transforms/interpolate.transform';\nimport {LocalizeReferenceTransform} from './transforms/reference.transform';\nimport {LocalizeLowercaseFunction} from './functions/lowercase.function';\nimport {LocalizeUppercaseFunction} from './functions/uppercase.function';\nimport {BbLocalizeTemplate} from './views/localize-template.directive';\nimport {LOCALIZE_TRANSFORM} from './interfaces/transforms.interfaces';\nimport {LOCALIZE_FUNCTION} from './interfaces/functions.interfaces';\nimport {LocalizeMissingHandler} from './handlers/missing.handler';\nimport {LocalizeDateFunction} from './functions/date.function';\nimport {LocalizeConfig} from './interfaces/config.interfaces';\nimport {UtilsModule} from '@bravobit/bb-foundation/utils';\nimport {CommonModule} from '@angular/common';\nimport {Localize} from './localize.service';\nimport {BbLocalize} from './localize.pipe';\n\n@NgModule({\n    imports: [CommonModule, UtilsModule],\n    declarations: [\n        BbLocalize,\n        BbLocalizeString,\n        BbLocalizeTemplate\n    ],\n    exports: [\n        BbLocalize,\n        BbLocalizeString,\n        BbLocalizeTemplate\n    ]\n})\nexport class LocalizeModule {\n\n    static forRoot(config: LocalizeConfig): ModuleWithProviders<LocalizeModule> {\n        if (config?.languages?.length <= 0) {\n            throw new Error('One or more languages should be supplied.');\n        }\n\n        if (config?.compareDictionaries && config?.mode === 'manual') {\n            console?.warn?.('You cannot enable \"compareDictionaries\" when having mode set to \"manual\"; This setting will be ignored.');\n        }\n\n        const mode = config?.mode ?? 'automatic';\n        return {\n            ngModule: LocalizeModule,\n            providers: [\n                // Angular providers.\n                ...(mode === 'automatic' ? [\n                    {provide: APP_INITIALIZER, deps: [Localize], useFactory: initializeLocale, multi: true},\n                    {provide: LOCALE_ID, deps: [Localize], useFactory: getLocale}\n                ] : []),\n                // Config provider.\n                {provide: LocalizeConfig, useValue: config},\n                // Function providers.\n                {provide: LOCALIZE_FUNCTION, useClass: LocalizeLowercaseFunction, multi: true},\n                {provide: LOCALIZE_FUNCTION, useClass: LocalizeUppercaseFunction, multi: true},\n                {provide: LOCALIZE_FUNCTION, useClass: LocalizeDateFunction, multi: true},\n                // Transform providers.\n                {provide: LOCALIZE_TRANSFORM, useClass: LocalizeReferenceTransform, deps: [LocalizeConfig], multi: true},\n                {provide: LOCALIZE_TRANSFORM, useClass: LocalizeInterpolateTransform, deps: [LocalizeConfig, LOCALIZE_FUNCTION], multi: true},\n                // Handler providers.\n                {provide: LocalizeMissingHandler, useClass: LocalizeMissingHandler},\n                // Service providers.\n                Localize\n            ]\n        };\n    }\n\n}\n\nexport function initializeLocale(localize: Localize) {\n    return localize.initialize();\n}\n\nexport function getLocale(localize: Localize) {\n    return localize?.current?.locale ?? null;\n}\n"]}

package/esm2022/localize/lib/localize.pipe.mjs

@@ -0,0 +1,47 @@
+import { Optional, Pipe } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "./localize.service";
+class BbLocalize {
+    constructor(_localize) {
+        this._localize = _localize;
+    }
+    transform(tokenOrParams, args) {
+        // Combine the params with the options to form the localize params.
+        const params = this.combineParamsWithOptions(tokenOrParams, args);
+        // Validate that the localize service exists in the pipe.
+        if (!this._localize) {
+            return params?.token ?? null;
+        }
+        // Try to localize the value.
+        return this._localize.translate(params);
+    }
+    combineParamsWithOptions(tokenOrParams, args) {
+        // Gather the extras.
+        const extras = args ?? {};
+        // Loop through all the keys to find the set options.
+        const options = Object.keys(extras).reduce((previous, current) => {
+            if (typeof extras?.[current] === 'undefined') {
+                return previous;
+            }
+            return { ...previous, [current]: extras?.[current] };
+        }, {});
+        // Convert the string token to a params object.
+        const params = typeof tokenOrParams === 'string'
+            ? { token: tokenOrParams, optional: false, data: {}, dictionary: null }
+            : tokenOrParams;
+        // Return the combined params and options.
+        return { ...params, ...options };
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: BbLocalize, deps: [{ token: i1.Localize, optional: true }], target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "16.0.0", ngImport: i0, type: BbLocalize, name: "bbLocalize" }); }
+}
+export { BbLocalize };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: BbLocalize, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'bbLocalize'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.Localize, decorators: [{
+                    type: Optional
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/localize/lib/localize.service.mjs

@@ -0,0 +1,186 @@
+import { LOCALIZE_TRANSFORM } from './interfaces/transforms.interfaces';
+import { LocalizeDictionary } from './dictionary/dictionary.class';
+import { Inject, Injectable, Optional } from '@angular/core';
+import { WINDOW } from '@bravobit/bb-foundation';
+import { DOCUMENT } from '@angular/common';
+import { BehaviorSubject } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "@bravobit/bb-foundation/storage";
+import * as i2 from "@bravobit/bb-foundation";
+import * as i3 from "./handlers/missing.handler";
+import * as i4 from "./interfaces/config.interfaces";
+class Localize {
+    constructor(_storage, _languages, _missingHandler, _config, _window, _document, _transforms) {
+        this._storage = _storage;
+        this._languages = _languages;
+        this._missingHandler = _missingHandler;
+        this._config = _config;
+        this._window = _window;
+        this._document = _document;
+        this._transforms = _transforms;
+        // Readonly data.
+        this._storageToken = this._config?.storageToken ?? 'bb-language-dictionary-id';
+        this._availableLanguages = this?._config?.languages ?? [];
+        this._bestMatchingLanguage = this.retrieveBestMatchingLanguage();
+        this._loadedDictionaries = new Map();
+        // Current dictionary.
+        this._current$ = new BehaviorSubject(null);
+        // State changes.
+        this.dictionaryChanges$ = this._current$.asObservable();
+        this.convertToParams = (tokenOrParams) => {
+            if (typeof tokenOrParams !== 'string') {
+                // Destruct the params from the object.
+                const { token, optional, dictionary, data } = tokenOrParams;
+                // Make sure all parameters are valid
+                // by type safe adding them.
+                return { token: token, optional: optional ?? false, dictionary: dictionary ?? null, data: data ?? {} };
+            }
+            // If the parameter is a string fill in the blanks.
+            return { token: tokenOrParams, optional: false, dictionary: null, data: {} };
+        };
+        this.renderDocumentLanguage();
+    }
+    get languages() {
+        return this._availableLanguages ?? [];
+    }
+    get current() {
+        return this._current$.getValue();
+    }
+    async load(id) {
+        if (id === null || id === undefined) {
+            throw new Error(`Cannot load language with id: "${id}".`);
+        }
+        if (this._loadedDictionaries.has(id)) {
+            return this._loadedDictionaries.get(id);
+        }
+        const language = this.languages?.find(language => language?.id === id);
+        if (!language || !language?.data) {
+            console?.warn?.(`No language was found with id: "${id}"; Defaulting to first available language.`);
+            const languageId = this.languages?.[0]?.id ?? null;
+            return this.load(languageId);
+        }
+        const dictionaryDataValues = await language?.data?.();
+        const dictionary = this.createDictionary(dictionaryDataValues, language);
+        this._loadedDictionaries.set(id, dictionary);
+        return dictionary;
+    }
+    async loadAllLanguages() {
+        for (const language of this.languages) {
+            await this.load(this.current?.id);
+        }
+    }
+    async switch(id, options) {
+        const dictionary = await this.load(id);
+        this._current$.next(dictionary);
+        const cache = options?.cache ?? true;
+        if (cache) {
+            this._storage.cookie.set(this._storageToken, dictionary?.id, {});
+        }
+        const reload = options?.reload ?? false;
+        if (reload) {
+            this._window?.location?.reload?.();
+        }
+        return dictionary;
+    }
+    select(id) {
+        if (!this._loadedDictionaries.has(id)) {
+            throw new Error(`Dictionary with id: "${id}" not loaded; Load dictionary first before using .select(:id).`);
+        }
+        return this._loadedDictionaries.get(id);
+    }
+    initialize() {
+        return async () => {
+            await this.switch(this._bestMatchingLanguage?.id, { reload: false, cache: false });
+            return this.compareDictionaries();
+        };
+    }
+    clear() {
+        this._storage.cookie.remove(this._storageToken);
+    }
+    transform(value, data = {}) {
+        return (this._transforms ?? []).reduce((previous, current) => {
+            return current.execute(previous, data, this);
+        }, value);
+    }
+    translate(tokenOrParams) {
+        // 1. Convert to the params.
+        const params = this.convertToParams(tokenOrParams);
+        // 2. Try to find the translation in the dictionary.
+        const dictionary = this.getDictionary(params?.dictionary);
+        const searchResult = !!dictionary ? dictionary.get(params?.token) : null;
+        // 3. Verify the translation was found.
+        if (!searchResult) {
+            return this._missingHandler.handle(params);
+        }
+        return this.transform(searchResult, params?.data);
+    }
+    retrieveBestMatchingLanguage() {
+        return this.getLanguageFromStorage()
+            ?? this.getBestBrowserMatchLanguage()
+            ?? this._availableLanguages?.[0];
+    }
+    getLanguageFromStorage() {
+        // Get id from the storage.
+        const id = this._storage.cookie.get(this._storageToken);
+        // Return the language based on the storage id.
+        return this._availableLanguages.find(item => item?.id === id);
+    }
+    getBestBrowserMatchLanguage() {
+        // Loop through all browser languages and return the
+        // best matching language.
+        return this._languages.all.map(({ code, region }) => {
+            const languageCode = [code, region].filter(data => !!data).join('-');
+            return this._availableLanguages.find(item => item?.supported?.includes(languageCode));
+        }).filter(item => !!item).find((_, index) => index === 0);
+    }
+    createDictionary(data, language) {
+        return new LocalizeDictionary(language?.id, language?.locale, language?.supported, data?.data, this);
+    }
+    getDictionary(id) {
+        if (id === null || id === undefined) {
+            return this.current;
+        }
+        return this.select(id);
+    }
+    renderDocumentLanguage() {
+        const element = this._document?.documentElement;
+        if (!element) {
+            return;
+        }
+        element.lang = this._bestMatchingLanguage?.supported?.[0] ?? this._bestMatchingLanguage?.locale;
+    }
+    async compareDictionaries() {
+        const compareDictionaries = this._config.compareDictionaries ?? false;
+        if (!compareDictionaries || !this.current) {
+            return;
+        }
+        const languageIds = (this.languages ?? [])
+            ?.filter(language => language?.id !== this.current?.id)
+            ?.map(language => language?.id);
+        return await this.current.compare(languageIds);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: Localize, deps: [{ token: i1.Storage }, { token: i2.Languages }, { token: i3.LocalizeMissingHandler }, { token: i4.LocalizeConfig, optional: true }, { token: WINDOW, optional: true }, { token: DOCUMENT, optional: true }, { token: LOCALIZE_TRANSFORM, optional: true }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: Localize }); }
+}
+export { Localize };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: Localize, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.Storage }, { type: i2.Languages }, { type: i3.LocalizeMissingHandler }, { type: i4.LocalizeConfig, decorators: [{
+                    type: Optional
+                }] }, { type: Window, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [WINDOW]
+                }] }, { type: Document, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [DOCUMENT]
+                }] }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [LOCALIZE_TRANSFORM]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"localize.service.js","sourceRoot":"","sources":["../../../../../projects/bb-foundation/localize/src/lib/localize.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {LocalizeConfig, LocalizeConfigLanguage} from './interfaces/config.interfaces';\nimport {LOCALIZE_TRANSFORM} from './interfaces/transforms.interfaces';\nimport {LocalizeDictionaryData} from './dictionary/dictionary.data';\nimport {LocalizeTransform} from './transforms/abstract.transform';\nimport {LocalizeMissingHandler} from './handlers/missing.handler';\nimport {LocalizeDictionary} from './dictionary/dictionary.class';\nimport {LocalizeParams} from './interfaces/options.interfaces';\nimport {Inject, Injectable, Optional} from '@angular/core';\nimport {Languages, WINDOW} from '@bravobit/bb-foundation';\nimport {Storage} from '@bravobit/bb-foundation/storage';\nimport {DOCUMENT} from '@angular/common';\nimport {BehaviorSubject} from 'rxjs';\n\n@Injectable()\nexport class Localize {\n\n    // Readonly data.\n    private readonly _storageToken: string = this._config?.storageToken ?? 'bb-language-dictionary-id';\n    private readonly _availableLanguages: LocalizeConfigLanguage[] = this?._config?.languages ?? [];\n    private readonly _bestMatchingLanguage: LocalizeConfigLanguage = this.retrieveBestMatchingLanguage();\n\n    private readonly _loadedDictionaries: Map<string, LocalizeDictionary> = new Map<string, LocalizeDictionary>();\n\n    // Current dictionary.\n    private _current$ = new BehaviorSubject<LocalizeDictionary | null>(null);\n\n    // State changes.\n    dictionaryChanges$ = this._current$.asObservable();\n\n    constructor(private _storage: Storage,\n                private _languages: Languages,\n                private _missingHandler: LocalizeMissingHandler,\n                @Optional() private _config?: LocalizeConfig,\n                @Optional() @Inject(WINDOW) private _window?: Window,\n                @Optional() @Inject(DOCUMENT) private _document?: Document,\n                @Optional() @Inject(LOCALIZE_TRANSFORM) private _transforms?: LocalizeTransform[]) {\n        this.renderDocumentLanguage();\n    }\n\n    get languages() {\n        return this._availableLanguages ?? [];\n    }\n\n    get current() {\n        return this._current$.getValue();\n    }\n\n    async load(id: string) {\n        if (id === null || id === undefined) {\n            throw new Error(`Cannot load language with id: \"${id}\".`);\n        }\n\n        if (this._loadedDictionaries.has(id)) {\n            return this._loadedDictionaries.get(id);\n        }\n\n        const language = this.languages?.find(language => language?.id === id);\n        if (!language || !language?.data) {\n            console?.warn?.(`No language was found with id: \"${id}\"; Defaulting to first available language.`);\n            const languageId = this.languages?.[0]?.id ?? null;\n            return this.load(languageId);\n        }\n\n        const dictionaryDataValues = await language?.data?.();\n        const dictionary = this.createDictionary(dictionaryDataValues, language);\n        this._loadedDictionaries.set(id, dictionary);\n        return dictionary;\n    }\n\n    async loadAllLanguages() {\n        for (const language of this.languages) {\n            await this.load(this.current?.id);\n        }\n    }\n\n    async switch(id: string, options?: { cache?: boolean, reload?: boolean }) {\n        const dictionary = await this.load(id);\n        this._current$.next(dictionary);\n\n        const cache = options?.cache ?? true;\n        if (cache) {\n            this._storage.cookie.set<string>(this._storageToken, dictionary?.id, {});\n        }\n\n        const reload = options?.reload ?? false;\n        if (reload) {\n            this._window?.location?.reload?.();\n        }\n\n        return dictionary;\n    }\n\n    select(id: string) {\n        if (!this._loadedDictionaries.has(id)) {\n            throw new Error(`Dictionary with id: \"${id}\" not loaded; Load dictionary first before using .select(:id).`);\n        }\n        return this._loadedDictionaries.get(id);\n    }\n\n    initialize() {\n        return async () => {\n            await this.switch(this._bestMatchingLanguage?.id, {reload: false, cache: false});\n            return this.compareDictionaries();\n        };\n    }\n\n    clear() {\n        this._storage.cookie.remove(this._storageToken);\n    }\n\n    transform(value: string, data: LocalizeParams['data'] = {}) {\n        return (this._transforms ?? []).reduce((previous, current) => {\n            return current.execute(previous, data, this);\n        }, value);\n    }\n\n    translate(tokenOrParams: string | LocalizeParams) {\n        // 1. Convert to the params.\n        const params = this.convertToParams(tokenOrParams);\n\n        // 2. Try to find the translation in the dictionary.\n        const dictionary = this.getDictionary(params?.dictionary);\n        const searchResult = !!dictionary ? dictionary.get(params?.token) : null;\n\n        // 3. Verify the translation was found.\n        if (!searchResult) {\n            return this._missingHandler.handle(params);\n        }\n\n        return this.transform(searchResult, params?.data);\n    }\n\n    private retrieveBestMatchingLanguage() {\n        return this.getLanguageFromStorage()\n            ?? this.getBestBrowserMatchLanguage()\n            ?? this._availableLanguages?.[0];\n    }\n\n    private getLanguageFromStorage() {\n        // Get id from the storage.\n        const id = this._storage.cookie.get<string>(this._storageToken);\n\n        // Return the language based on the storage id.\n        return this._availableLanguages.find(item => item?.id === id);\n    }\n\n    private getBestBrowserMatchLanguage() {\n        // Loop through all browser languages and return the\n        // best matching language.\n        return this._languages.all.map(({code, region}) => {\n            const languageCode = [code, region].filter(data => !!data).join('-');\n\n            return this._availableLanguages.find(item => item?.supported?.includes(languageCode));\n        }).filter(item => !!item).find((_, index) => index === 0);\n    }\n\n    private createDictionary(data: LocalizeDictionaryData, language: LocalizeConfigLanguage) {\n        return new LocalizeDictionary(language?.id, language?.locale, language?.supported, data?.data, this);\n    }\n\n    private getDictionary(id: string | null) {\n        if (id === null || id === undefined) {\n            return this.current;\n        }\n        return this.select(id);\n    }\n\n    private renderDocumentLanguage() {\n        const element = this._document?.documentElement;\n        if (!element) {\n            return;\n        }\n\n        element.lang = this._bestMatchingLanguage?.supported?.[0] ?? this._bestMatchingLanguage?.locale;\n    }\n\n    private async compareDictionaries() {\n        const compareDictionaries = this._config.compareDictionaries ?? false;\n        if (!compareDictionaries || !this.current) {\n            return;\n        }\n\n        const languageIds = (this.languages ?? [])\n            ?.filter(language => language?.id !== this.current?.id)\n            ?.map(language => language?.id);\n\n        return await this.current.compare(languageIds);\n    }\n\n    private convertToParams = (tokenOrParams: string | LocalizeParams) => {\n        if (typeof tokenOrParams !== 'string') {\n            // Destruct the params from the object.\n            const {token, optional, dictionary, data} = tokenOrParams;\n\n            // Make sure all parameters are valid\n            // by type safe adding them.\n            return {token: token, optional: optional ?? false, dictionary: dictionary ?? null, data: data ?? {}};\n        }\n\n        // If the parameter is a string fill in the blanks.\n        return {token: tokenOrParams, optional: false, dictionary: null, data: {}};\n    };\n\n}\n"]}