@net7/boilerplate-common 3.0.1-rc.2

package/esm2020/lib/layouts/main-layout/main-layout.ds.mjs

@@ -0,0 +1,83 @@
+import { LayoutDataSource } from '@n7-frontend/core';
+import { hideAll } from 'tippy.js';
+export class MainLayoutDS extends LayoutDataSource {
+    onInit({ configuration, mainState, router, options, titleService, route, }) {
+        this.configuration = configuration;
+        this.mainState = mainState;
+        this.router = router;
+        this.route = route;
+        this.titleService = titleService;
+        this.options = options;
+        // update header
+        if (this.configuration.get('header')) {
+            this.one('header').update(this.configuration.get('header'));
+        }
+        if (this.configuration.get('footer')) {
+            this.one('footer').update(this.configuration.get('footer'));
+        }
+        // main state updates
+        this.mainState.get$('headTitle').subscribe((val) => {
+            this.titleService.setTitle(val);
+        });
+        this.mainState.get$('pageTitle').subscribe((val) => {
+            this.pageTitle = val;
+        });
+        this.mainState.get$('subnav').subscribe((val) => {
+            this.one('subnav').update(val);
+        });
+        this.mainState.get$('breadcrumbs').subscribe((val) => {
+            this.one('breadcrumbs').update(val);
+        });
+        this.mainState.get$('header').subscribe((val) => {
+            this.one('header').update(val);
+        });
+        // mainState test
+        /* this.mainState.addCustom('customNav', new Subject());
+        this.mainState.get$('pageTitle').subscribe(val => console.log('pageTitle', val));
+        this.mainState.getCustom$('customNav').subscribe(val => console.log('customNav', val));
+    
+        this.mainState.update('pageTitle', 'hola');
+        this.mainState.updateCustom('customNav', {'hello': 'mundo!'});
+    
+        setTimeout(() => {
+          this.mainState.update('pageTitle', 'chao');
+          this.mainState.updateCustom('customNav', {'hello': 'world!'});
+          console.log('has', {
+            'pageSubTitle' : this.mainState.has('pageSubTitle'),
+            'customNav' : this.mainState.hasCustom('customNav'),
+            'customNavs' : this.mainState.has('customNavs'),
+          });
+        }, 5000); */
+    }
+    // navigate emitter (click) handler
+    onNavigate(payload) {
+        // router navigation
+        if (payload.handler === 'router') {
+            const { path, queryParams } = payload;
+            // path control
+            if (!path)
+                throw Error('onNavigate: no path for router navigate');
+            if (queryParams) {
+                this.router.navigate(path, {
+                    relativeTo: this.route,
+                    queryParams,
+                    queryParamsHandling: 'merge',
+                });
+            }
+            else {
+                this.router.navigate(path);
+            }
+            // on change
+            this._onRouterNavigate();
+        }
+    }
+    // links routerLink change handler
+    onRouterChanged() {
+        hideAll();
+    }
+    _onRouterNavigate() {
+        // hide tippy
+        hideAll();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/layouts/main-layout/main-layout.eh.mjs

@@ -0,0 +1,60 @@
+import { EventHandler } from '@n7-frontend/core';
+import { Subject } from 'rxjs';
+import { takeUntil, filter } from 'rxjs/operators';
+import { NavigationStart } from '@angular/router';
+export class MainLayoutEH extends EventHandler {
+    constructor() {
+        super(...arguments);
+        this.destroyed$ = new Subject();
+    }
+    listen() {
+        this.innerEvents$.subscribe(({ type, payload }) => {
+            switch (type) {
+                case 'main-layout.init':
+                    this.dataSource.onInit(payload);
+                    this.mainState = payload.mainState;
+                    this.route = payload.route;
+                    this.router = payload.router;
+                    this._listenRouterChanges();
+                    this._listenMainStateChanges();
+                    break;
+                case 'main-layout.destroy':
+                    this.destroyed$.next();
+                    break;
+                default:
+                    break;
+            }
+        });
+        // listen to global events
+        EventHandler.globalEvents$.pipe(takeUntil(this.destroyed$)).subscribe(({ type, payload }) => {
+            switch (type) {
+                case 'global.navigate':
+                    this.dataSource.onNavigate(payload);
+                    break;
+                default:
+                    break;
+            }
+        });
+    }
+    _listenRouterChanges() {
+        this.route.queryParams.pipe(filter((params) => {
+            if (Object.keys(params).length)
+                return true;
+            return false;
+        })).subscribe((params) => {
+            this.emitGlobal('queryparams', params);
+        });
+        // router changed
+        this.router.events.pipe(filter((event) => event instanceof NavigationStart)).subscribe(() => {
+            this.emitOuter('routerchange');
+            this.dataSource.onRouterChanged();
+        });
+    }
+    _listenMainStateChanges() {
+        this.mainState.addCustom('currentNav', new Subject());
+        this.mainState.getCustom$('currentNav').subscribe((val) => {
+            this.emitOuter('currentnavchange', val);
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWFpbi1sYXlvdXQuZWguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9uNy1ib2lsZXJwbGF0ZS1jb21tb24vc3JjL2xpYi9sYXlvdXRzL21haW4tbGF5b3V0L21haW4tbGF5b3V0LmVoLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxtQkFBbUIsQ0FBQztBQUNqRCxPQUFPLEVBQUUsT0FBTyxFQUFFLE1BQU0sTUFBTSxDQUFDO0FBQy9CLE9BQU8sRUFBRSxTQUFTLEVBQUUsTUFBTSxFQUFFLE1BQU0sZ0JBQWdCLENBQUM7QUFDbkQsT0FBTyxFQUFFLGVBQWUsRUFBRSxNQUFNLGlCQUFpQixDQUFDO0FBRWxELE1BQU0sT0FBTyxZQUFhLFNBQVEsWUFBWTtJQUE5Qzs7UUFDVSxlQUFVLEdBQWlCLElBQUksT0FBTyxFQUFFLENBQUM7SUFxRW5ELENBQUM7SUE3RFEsTUFBTTtRQUNYLElBQUksQ0FBQyxZQUFZLENBQUMsU0FBUyxDQUFDLENBQUMsRUFBRSxJQUFJLEVBQUUsT0FBTyxFQUFFLEVBQUUsRUFBRTtZQUNoRCxRQUFRLElBQUksRUFBRTtnQkFDWixLQUFLLGtCQUFrQjtvQkFDckIsSUFBSSxDQUFDLFVBQVUsQ0FBQyxNQUFNLENBQUMsT0FBTyxDQUFDLENBQUM7b0JBQ2hDLElBQUksQ0FBQyxTQUFTLEdBQUcsT0FBTyxDQUFDLFNBQVMsQ0FBQztvQkFDbkMsSUFBSSxDQUFDLEtBQUssR0FBRyxPQUFPLENBQUMsS0FBSyxDQUFDO29CQUMzQixJQUFJLENBQUMsTUFBTSxHQUFHLE9BQU8sQ0FBQyxNQUFNLENBQUM7b0JBRTdCLElBQUksQ0FBQyxvQkFBb0IsRUFBRSxDQUFDO29CQUM1QixJQUFJLENBQUMsdUJBQXVCLEVBQUUsQ0FBQztvQkFDL0IsTUFBTTtnQkFFUixLQUFLLHFCQUFxQjtvQkFDeEIsSUFBSSxDQUFDLFVBQVUsQ0FBQyxJQUFJLEVBQUUsQ0FBQztvQkFDdkIsTUFBTTtnQkFFUjtvQkFDRSxNQUFNO2FBQ1Q7UUFDSCxDQUFDLENBQUMsQ0FBQztRQUVILDBCQUEwQjtRQUMxQixZQUFZLENBQUMsYUFBYSxDQUFDLElBQUksQ0FDN0IsU0FBUyxDQUFDLElBQUksQ0FBQyxVQUFVLENBQUMsQ0FDM0IsQ0FBQyxTQUFTLENBQUMsQ0FBQyxFQUFFLElBQUksRUFBRSxPQUFPLEVBQUUsRUFBRSxFQUFFO1lBQ2hDLFFBQVEsSUFBSSxFQUFFO2dCQUNaLEtBQUssaUJBQWlCO29CQUNwQixJQUFJLENBQUMsVUFBVSxDQUFDLFVBQVUsQ0FBQyxPQUFPLENBQUMsQ0FBQztvQkFDcEMsTUFBTTtnQkFFUjtvQkFDRSxNQUFNO2FBQ1Q7UUFDSCxDQUFDLENBQUMsQ0FBQztJQUNMLENBQUM7SUFFTyxvQkFBb0I7UUFDMUIsSUFBSSxDQUFDLEtBQUssQ0FBQyxXQUFXLENBQUMsSUFBSSxDQUN6QixNQUFNLENBQUMsQ0FBQyxNQUFNLEVBQUUsRUFBRTtZQUNoQixJQUFJLE1BQU0sQ0FBQyxJQUFJLENBQUMsTUFBTSxDQUFDLENBQUMsTUFBTTtnQkFBRSxPQUFPLElBQUksQ0FBQztZQUM1QyxPQUFPLEtBQUssQ0FBQztRQUNmLENBQUMsQ0FBQyxDQUNILENBQUMsU0FBUyxDQUFDLENBQUMsTUFBTSxFQUFFLEVBQUU7WUFDckIsSUFBSSxDQUFDLFVBQVUsQ0FBQyxhQUFhLEVBQUUsTUFBTSxDQUFDLENBQUM7UUFDekMsQ0FBQyxDQUFDLENBQUM7UUFDSCxpQkFBaUI7UUFDakIsSUFBSSxDQUFDLE1BQU0sQ0FBQyxNQUFNLENBQUMsSUFBSSxDQUNyQixNQUFNLENBQUMsQ0FBQyxLQUFLLEVBQUUsRUFBRSxDQUFDLEtBQUssWUFBWSxlQUFlLENBQUMsQ0FDcEQsQ0FBQyxTQUFTLENBQUMsR0FBRyxFQUFFO1lBQ2YsSUFBSSxDQUFDLFNBQVMsQ0FBQyxjQUFjLENBQUMsQ0FBQztZQUMvQixJQUFJLENBQUMsVUFBVSxDQUFDLGVBQWUsRUFBRSxDQUFDO1FBQ3BDLENBQUMsQ0FBQyxDQUFDO0lBQ0wsQ0FBQztJQUVPLHVCQUF1QjtRQUM3QixJQUFJLENBQUMsU0FBUyxDQUFDLFNBQVMsQ0FBQyxZQUFZLEVBQUUsSUFBSSxPQUFPLEVBQUUsQ0FBQyxDQUFDO1FBQ3RELElBQUksQ0FBQyxTQUFTLENBQUMsVUFBVSxDQUFDLFlBQVksQ0FBQyxDQUFDLFNBQVMsQ0FBQyxDQUFDLEdBQUcsRUFBRSxFQUFFO1lBQ3hELElBQUksQ0FBQyxTQUFTLENBQUMsa0JBQWtCLEVBQUUsR0FBRyxDQUFDLENBQUM7UUFDMUMsQ0FBQyxDQUFDLENBQUM7SUFDTCxDQUFDO0NBQ0YiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBFdmVudEhhbmRsZXIgfSBmcm9tICdAbjctZnJvbnRlbmQvY29yZSc7XG5pbXBvcnQgeyBTdWJqZWN0IH0gZnJvbSAncnhqcyc7XG5pbXBvcnQgeyB0YWtlVW50aWwsIGZpbHRlciB9IGZyb20gJ3J4anMvb3BlcmF0b3JzJztcbmltcG9ydCB7IE5hdmlnYXRpb25TdGFydCB9IGZyb20gJ0Bhbmd1bGFyL3JvdXRlcic7XG5cbmV4cG9ydCBjbGFzcyBNYWluTGF5b3V0RUggZXh0ZW5kcyBFdmVudEhhbmRsZXIge1xuICBwcml2YXRlIGRlc3Ryb3llZCQ6IFN1YmplY3Q8YW55PiA9IG5ldyBTdWJqZWN0KCk7XG5cbiAgcHJpdmF0ZSByb3V0ZTogYW55O1xuXG4gIHByaXZhdGUgcm91dGVyOiBhbnk7XG5cbiAgcHJpdmF0ZSBtYWluU3RhdGU6IGFueTtcblxuICBwdWJsaWMgbGlzdGVuKCkge1xuICAgIHRoaXMuaW5uZXJFdmVudHMkLnN1YnNjcmliZSgoeyB0eXBlLCBwYXlsb2FkIH0pID0+IHtcbiAgICAgIHN3aXRjaCAodHlwZSkge1xuICAgICAgICBjYXNlICdtYWluLWxheW91dC5pbml0JzpcbiAgICAgICAgICB0aGlzLmRhdGFTb3VyY2Uub25Jbml0KHBheWxvYWQpO1xuICAgICAgICAgIHRoaXMubWFpblN0YXRlID0gcGF5bG9hZC5tYWluU3RhdGU7XG4gICAgICAgICAgdGhpcy5yb3V0ZSA9IHBheWxvYWQucm91dGU7XG4gICAgICAgICAgdGhpcy5yb3V0ZXIgPSBwYXlsb2FkLnJvdXRlcjtcblxuICAgICAgICAgIHRoaXMuX2xpc3RlblJvdXRlckNoYW5nZXMoKTtcbiAgICAgICAgICB0aGlzLl9saXN0ZW5NYWluU3RhdGVDaGFuZ2VzKCk7XG4gICAgICAgICAgYnJlYWs7XG5cbiAgICAgICAgY2FzZSAnbWFpbi1sYXlvdXQuZGVzdHJveSc6XG4gICAgICAgICAgdGhpcy5kZXN0cm95ZWQkLm5leHQoKTtcbiAgICAgICAgICBicmVhaztcblxuICAgICAgICBkZWZhdWx0OlxuICAgICAgICAgIGJyZWFrO1xuICAgICAgfVxuICAgIH0pO1xuXG4gICAgLy8gbGlzdGVuIHRvIGdsb2JhbCBldmVudHNcbiAgICBFdmVudEhhbmRsZXIuZ2xvYmFsRXZlbnRzJC5waXBlKFxuICAgICAgdGFrZVVudGlsKHRoaXMuZGVzdHJveWVkJCksXG4gICAgKS5zdWJzY3JpYmUoKHsgdHlwZSwgcGF5bG9hZCB9KSA9PiB7XG4gICAgICBzd2l0Y2ggKHR5cGUpIHtcbiAgICAgICAgY2FzZSAnZ2xvYmFsLm5hdmlnYXRlJzpcbiAgICAgICAgICB0aGlzLmRhdGFTb3VyY2Uub25OYXZpZ2F0ZShwYXlsb2FkKTtcbiAgICAgICAgICBicmVhaztcblxuICAgICAgICBkZWZhdWx0OlxuICAgICAgICAgIGJyZWFrO1xuICAgICAgfVxuICAgIH0pO1xuICB9XG5cbiAgcHJpdmF0ZSBfbGlzdGVuUm91dGVyQ2hhbmdlcygpIHtcbiAgICB0aGlzLnJvdXRlLnF1ZXJ5UGFyYW1zLnBpcGUoXG4gICAgICBmaWx0ZXIoKHBhcmFtcykgPT4ge1xuICAgICAgICBpZiAoT2JqZWN0LmtleXMocGFyYW1zKS5sZW5ndGgpIHJldHVybiB0cnVlO1xuICAgICAgICByZXR1cm4gZmFsc2U7XG4gICAgICB9KSxcbiAgICApLnN1YnNjcmliZSgocGFyYW1zKSA9PiB7XG4gICAgICB0aGlzLmVtaXRHbG9iYWwoJ3F1ZXJ5cGFyYW1zJywgcGFyYW1zKTtcbiAgICB9KTtcbiAgICAvLyByb3V0ZXIgY2hhbmdlZFxuICAgIHRoaXMucm91dGVyLmV2ZW50cy5waXBlKFxuICAgICAgZmlsdGVyKChldmVudCkgPT4gZXZlbnQgaW5zdGFuY2VvZiBOYXZpZ2F0aW9uU3RhcnQpLFxuICAgICkuc3Vic2NyaWJlKCgpID0+IHtcbiAgICAgIHRoaXMuZW1pdE91dGVyKCdyb3V0ZXJjaGFuZ2UnKTtcbiAgICAgIHRoaXMuZGF0YVNvdXJjZS5vblJvdXRlckNoYW5nZWQoKTtcbiAgICB9KTtcbiAgfVxuXG4gIHByaXZhdGUgX2xpc3Rlbk1haW5TdGF0ZUNoYW5nZXMoKSB7XG4gICAgdGhpcy5tYWluU3RhdGUuYWRkQ3VzdG9tKCdjdXJyZW50TmF2JywgbmV3IFN1YmplY3QoKSk7XG4gICAgdGhpcy5tYWluU3RhdGUuZ2V0Q3VzdG9tJCgnY3VycmVudE5hdicpLnN1YnNjcmliZSgodmFsKSA9PiB7XG4gICAgICB0aGlzLmVtaXRPdXRlcignY3VycmVudG5hdmNoYW5nZScsIHZhbCk7XG4gICAgfSk7XG4gIH1cbn1cbiJdfQ==

package/esm2020/lib/layouts/main-layout/main-layout.mjs

@@ -0,0 +1,45 @@
+import { Component } from '@angular/core';
+import { AbstractLayout } from '../../models/abstract-layout';
+import { MainLayoutConfig as config } from './main-layout.config';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/router";
+import * as i2 from "../../services/configuration.service";
+import * as i3 from "../../services/layouts-configuration.service";
+import * as i4 from "../../services/main-state.service";
+import * as i5 from "@angular/platform-browser";
+import * as i6 from "@n7-frontend/components";
+import * as i7 from "@angular/common";
+export class MainLayoutComponent extends AbstractLayout {
+    constructor(router, route, configuration, layoutsConfiguration, mainState, titleService) {
+        super(layoutsConfiguration.get('MainLayoutConfig') || config);
+        this.router = router;
+        this.route = route;
+        this.configuration = configuration;
+        this.layoutsConfiguration = layoutsConfiguration;
+        this.mainState = mainState;
+        this.titleService = titleService;
+    }
+    initPayload() {
+        return {
+            configuration: this.configuration,
+            mainState: this.mainState,
+            router: this.router,
+            route: this.route,
+            titleService: this.titleService,
+            options: this.config.options || {},
+        };
+    }
+    ngOnInit() {
+        this.onInit();
+    }
+    ngOnDestroy() {
+        this.onDestroy();
+    }
+}
+MainLayoutComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.1", ngImport: i0, type: MainLayoutComponent, deps: [{ token: i1.Router }, { token: i1.ActivatedRoute }, { token: i2.ConfigurationService }, { token: i3.LayoutsConfigurationService }, { token: i4.MainStateService }, { token: i5.Title }], target: i0.ɵɵFactoryTarget.Component });
+MainLayoutComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.1", type: MainLayoutComponent, selector: "main-layout", usesInheritance: true, ngImport: i0, template: "<div class=\"n7-main-layout\" id=\"main-layout\">\n    <div class=\"n7-page-content\">\n        <n7-header\n            [data]=\"lb.widgets['header'].ds.out$ | async\"\n            [emit]=\"lb.widgets['header'].emit\">\n        </n7-header>\n        <main class=\"n7-content\">\n            <div class=\"n7-top-page-bar\">\n                <div class=\"n7-top-page-bar__main\"></div>\n            </div>\n            <div class=\"n7-alert-bar\">\n                <!--<n7-alert\n                [attr.id]=\"'main-layout-alert'\"\n                [data]=\"lb.dataSource.alertData$ | async\"\n                [emit]=\"lb.dataSource.closeAlert.bind(lb.dataSource)\"></n7-alert>-->\n            </div>\n            <ng-content></ng-content>\n        </main>\n    </div>\n    <n7-footer\n        [data]=\"lb.widgets['footer'].ds.out$ | async\"\n        [emit]=\"lb.widgets['footer'].emit\">\n    </n7-footer>\n</div>\n", components: [{ type: i6.HeaderComponent, selector: "n7-header", inputs: ["data", "emit"] }, { type: i6.FooterComponent, selector: "n7-footer", inputs: ["data", "emit"] }], pipes: { "async": i7.AsyncPipe } });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.1", ngImport: i0, type: MainLayoutComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'main-layout', template: "<div class=\"n7-main-layout\" id=\"main-layout\">\n    <div class=\"n7-page-content\">\n        <n7-header\n            [data]=\"lb.widgets['header'].ds.out$ | async\"\n            [emit]=\"lb.widgets['header'].emit\">\n        </n7-header>\n        <main class=\"n7-content\">\n            <div class=\"n7-top-page-bar\">\n                <div class=\"n7-top-page-bar__main\"></div>\n            </div>\n            <div class=\"n7-alert-bar\">\n                <!--<n7-alert\n                [attr.id]=\"'main-layout-alert'\"\n                [data]=\"lb.dataSource.alertData$ | async\"\n                [emit]=\"lb.dataSource.closeAlert.bind(lb.dataSource)\"></n7-alert>-->\n            </div>\n            <ng-content></ng-content>\n        </main>\n    </div>\n    <n7-footer\n        [data]=\"lb.widgets['footer'].ds.out$ | async\"\n        [emit]=\"lb.widgets['footer'].emit\">\n    </n7-footer>\n</div>\n" }]
+        }], ctorParameters: function () { return [{ type: i1.Router }, { type: i1.ActivatedRoute }, { type: i2.ConfigurationService }, { type: i3.LayoutsConfigurationService }, { type: i4.MainStateService }, { type: i5.Title }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/layouts/page404-layout/page404-layout.config.mjs

@@ -0,0 +1,16 @@
+import { Page404LayoutDS } from './page404-layout.ds';
+import { Page404LayoutEH } from './page404-layout.eh';
+import * as DS from '../../data-sources';
+import * as EH from '../../event-handlers';
+export const Page404LayoutConfig = {
+    layoutId: 'n7-page404-layout',
+    widgets: [],
+    layoutDS: Page404LayoutDS,
+    layoutEH: Page404LayoutEH,
+    widgetsDataSources: DS,
+    widgetsEventHandlers: EH,
+    options: {
+    // TODO
+    },
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGFnZTQwNC1sYXlvdXQuY29uZmlnLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvbjctYm9pbGVycGxhdGUtY29tbW9uL3NyYy9saWIvbGF5b3V0cy9wYWdlNDA0LWxheW91dC9wYWdlNDA0LWxheW91dC5jb25maWcudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLGVBQWUsRUFBRSxNQUFNLHFCQUFxQixDQUFDO0FBQ3RELE9BQU8sRUFBRSxlQUFlLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQztBQUN0RCxPQUFPLEtBQUssRUFBRSxNQUFNLG9CQUFvQixDQUFDO0FBQ3pDLE9BQU8sS0FBSyxFQUFFLE1BQU0sc0JBQXNCLENBQUM7QUFFM0MsTUFBTSxDQUFDLE1BQU0sbUJBQW1CLEdBQUc7SUFDakMsUUFBUSxFQUFFLG1CQUFtQjtJQUM3QixPQUFPLEVBQUUsRUFBRTtJQUNYLFFBQVEsRUFBRSxlQUFlO0lBQ3pCLFFBQVEsRUFBRSxlQUFlO0lBQ3pCLGtCQUFrQixFQUFFLEVBQUU7SUFDdEIsb0JBQW9CLEVBQUUsRUFBRTtJQUN4QixPQUFPLEVBQUU7SUFDUCxPQUFPO0tBQ1I7Q0FDRixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgUGFnZTQwNExheW91dERTIH0gZnJvbSAnLi9wYWdlNDA0LWxheW91dC5kcyc7XG5pbXBvcnQgeyBQYWdlNDA0TGF5b3V0RUggfSBmcm9tICcuL3BhZ2U0MDQtbGF5b3V0LmVoJztcbmltcG9ydCAqIGFzIERTIGZyb20gJy4uLy4uL2RhdGEtc291cmNlcyc7XG5pbXBvcnQgKiBhcyBFSCBmcm9tICcuLi8uLi9ldmVudC1oYW5kbGVycyc7XG5cbmV4cG9ydCBjb25zdCBQYWdlNDA0TGF5b3V0Q29uZmlnID0ge1xuICBsYXlvdXRJZDogJ243LXBhZ2U0MDQtbGF5b3V0JyxcbiAgd2lkZ2V0czogW10sXG4gIGxheW91dERTOiBQYWdlNDA0TGF5b3V0RFMsXG4gIGxheW91dEVIOiBQYWdlNDA0TGF5b3V0RUgsXG4gIHdpZGdldHNEYXRhU291cmNlczogRFMsXG4gIHdpZGdldHNFdmVudEhhbmRsZXJzOiBFSCxcbiAgb3B0aW9uczoge1xuICAgIC8vIFRPRE9cbiAgfSxcbn07XG4iXX0=

package/esm2020/lib/layouts/page404-layout/page404-layout.ds.mjs

@@ -0,0 +1,7 @@
+import { LayoutDataSource } from '@n7-frontend/core';
+export class Page404LayoutDS extends LayoutDataSource {
+    onInit({ options }) {
+        this.options = options;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGFnZTQwNC1sYXlvdXQuZHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9uNy1ib2lsZXJwbGF0ZS1jb21tb24vc3JjL2xpYi9sYXlvdXRzL3BhZ2U0MDQtbGF5b3V0L3BhZ2U0MDQtbGF5b3V0LmRzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxnQkFBZ0IsRUFBRSxNQUFNLG1CQUFtQixDQUFDO0FBRXJELE1BQU0sT0FBTyxlQUFnQixTQUFRLGdCQUFnQjtJQUduRCxNQUFNLENBQUMsRUFBRSxPQUFPLEVBQUU7UUFDaEIsSUFBSSxDQUFDLE9BQU8sR0FBRyxPQUFPLENBQUM7SUFDekIsQ0FBQztDQUNGIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgTGF5b3V0RGF0YVNvdXJjZSB9IGZyb20gJ0BuNy1mcm9udGVuZC9jb3JlJztcblxuZXhwb3J0IGNsYXNzIFBhZ2U0MDRMYXlvdXREUyBleHRlbmRzIExheW91dERhdGFTb3VyY2Uge1xuICBwdWJsaWMgb3B0aW9uczogYW55O1xuXG4gIG9uSW5pdCh7IG9wdGlvbnMgfSkge1xuICAgIHRoaXMub3B0aW9ucyA9IG9wdGlvbnM7XG4gIH1cbn1cbiJdfQ==

package/esm2020/lib/layouts/page404-layout/page404-layout.eh.mjs

@@ -0,0 +1,36 @@
+import { EventHandler } from '@n7-frontend/core';
+import { Subject } from 'rxjs';
+export class Page404LayoutEH extends EventHandler {
+    constructor() {
+        super(...arguments);
+        this.destroyed$ = new Subject();
+    }
+    listen() {
+        this.innerEvents$.subscribe(({ type, payload }) => {
+            switch (type) {
+                case 'n7-page404-layout.init':
+                    this.dataSource.onInit(payload);
+                    break;
+                case 'n7-page404-layout.destroy':
+                    this.destroyed$.next();
+                    break;
+                default:
+                    break;
+            }
+        });
+        // listen to global events
+        /* EventHandler.globalEvents$.pipe(
+          takeUntil(this.destroyed$)
+        ).subscribe(({type, payload}) => {
+          switch(type){
+            case 'global.navigate':
+              this.dataSource.onNavigate(payload);
+              break;
+    
+            default:
+              break;
+          }
+        }); */
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/layouts/page404-layout/page404-layout.mjs

@@ -0,0 +1,28 @@
+import { Component } from '@angular/core';
+import { AbstractLayout } from '../../models/abstract-layout';
+import { Page404LayoutConfig as config } from './page404-layout.config';
+import * as i0 from "@angular/core";
+import * as i1 from "../../services/layouts-configuration.service";
+export class Page404LayoutComponent extends AbstractLayout {
+    constructor(layoutsConfiguration) {
+        super(layoutsConfiguration.get('Page404LayoutConfig') || config);
+    }
+    initPayload() {
+        return {
+            options: this.config.options || {},
+        };
+    }
+    ngOnInit() {
+        this.onInit();
+    }
+    ngOnDestroy() {
+        this.onDestroy();
+    }
+}
+Page404LayoutComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.1", ngImport: i0, type: Page404LayoutComponent, deps: [{ token: i1.LayoutsConfigurationService }], target: i0.ɵɵFactoryTarget.Component });
+Page404LayoutComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.1", type: Page404LayoutComponent, selector: "n7-page404-layout", usesInheritance: true, ngImport: i0, template: "<div class=\"n7-page404-layout\">\n    404 - Resource not found\n</div>" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.1", ngImport: i0, type: Page404LayoutComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'n7-page404-layout', template: "<div class=\"n7-page404-layout\">\n    404 - Resource not found\n</div>" }]
+        }], ctorParameters: function () { return [{ type: i1.LayoutsConfigurationService }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/models/abstract-layout.mjs

@@ -0,0 +1,27 @@
+import { LayoutBuilder } from '@n7-frontend/core';
+export class AbstractLayout {
+    constructor(config) {
+        this.config = config;
+        this.widgets = this.config.widgets;
+        this.lb = new LayoutBuilder(this.config.layoutId);
+    }
+    onInit() {
+        // on ready
+        this.lb.ready$.subscribe(() => {
+            this.lb.eventHandler.emitInner('init', this.initPayload());
+        });
+        const LayoutDS = this.config.layoutDS;
+        const LayoutEH = this.config.layoutEH;
+        this.lb.init({
+            widgetsConfig: this.widgets,
+            widgetsDataSources: this.config.widgetsDataSources,
+            widgetsEventHandlers: this.config.widgetsEventHandlers,
+            dataSource: new LayoutDS(),
+            eventHandler: new LayoutEH(),
+        });
+    }
+    onDestroy() {
+        this.lb.eventHandler.emitInner('destroy');
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/models/index.mjs

@@ -0,0 +1,2 @@
+export * from './abstract-layout';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9uNy1ib2lsZXJwbGF0ZS1jb21tb24vc3JjL2xpYi9tb2RlbHMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxtQkFBbUIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vYWJzdHJhY3QtbGF5b3V0JztcbiJdfQ==

package/esm2020/lib/n7-boilerplate-common.module.mjs

@@ -0,0 +1,61 @@
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { HttpClientModule } from '@angular/common/http';
+import { DvComponentsLibModule } from '@n7-frontend/components';
+// services
+import { ConfigurationService } from './services/configuration.service';
+import { LayoutsConfigurationService } from './services/layouts-configuration.service';
+import { MainStateService } from './services/main-state.service';
+import { CommunicationService } from './services/communication.service';
+// layouts
+import { MainLayoutComponent } from './layouts/main-layout/main-layout';
+import { Page404LayoutComponent } from './layouts/page404-layout/page404-layout';
+// components
+import { SmartPaginationComponent } from './components/smart-pagination/smart-pagination';
+import * as i0 from "@angular/core";
+const COMPONENTS = [
+    MainLayoutComponent,
+    Page404LayoutComponent,
+    SmartPaginationComponent,
+];
+export class N7BoilerplateCommonModule {
+    static forRoot(config) {
+        return {
+            ngModule: N7BoilerplateCommonModule,
+            providers: [
+                MainStateService,
+                ConfigurationService,
+                LayoutsConfigurationService,
+                CommunicationService,
+                { provide: 'config', useValue: config },
+            ],
+        };
+    }
+}
+N7BoilerplateCommonModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.1", ngImport: i0, type: N7BoilerplateCommonModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+N7BoilerplateCommonModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.2.1", ngImport: i0, type: N7BoilerplateCommonModule, declarations: [MainLayoutComponent,
+        Page404LayoutComponent,
+        SmartPaginationComponent], imports: [CommonModule,
+        HttpClientModule,
+        DvComponentsLibModule], exports: [MainLayoutComponent,
+        Page404LayoutComponent,
+        SmartPaginationComponent] });
+N7BoilerplateCommonModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.2.1", ngImport: i0, type: N7BoilerplateCommonModule, providers: [], imports: [[
+            CommonModule,
+            HttpClientModule,
+            DvComponentsLibModule,
+        ]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.1", ngImport: i0, type: N7BoilerplateCommonModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: COMPONENTS,
+                    imports: [
+                        CommonModule,
+                        HttpClientModule,
+                        DvComponentsLibModule,
+                    ],
+                    providers: [],
+                    exports: COMPONENTS
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/services/communication-providers/apollo.provider.mjs

@@ -0,0 +1,87 @@
+import { Injectable } from '@angular/core';
+import { map } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "../configuration.service";
+const DEFAULT_TREE_DEPTH = 15;
+export class ApolloProvider {
+    constructor(http, configuration) {
+        this.http = http;
+        this.configuration = configuration;
+    }
+    request$(providerConfig, requestId, options) {
+        const { params, method, httpOptions } = options;
+        const treeDepth = this.configuration.get('treeDepth') || DEFAULT_TREE_DEPTH;
+        const config = providerConfig.config ? providerConfig.config(treeDepth) : {};
+        let query;
+        if (config && config[requestId]) {
+            query = config[requestId];
+        }
+        query = query || {};
+        const { queryName } = query;
+        let { queryBody } = query;
+        // config query control
+        if (!queryName || !queryBody) {
+            throw Error(`No config found for requestId '${requestId}'`);
+        }
+        if (params) {
+            const paramsStr = this.makeParamsStr(params);
+            queryBody = queryBody.replace('__PARAMS__', paramsStr);
+        }
+        else {
+            queryBody = queryBody.replace('(__PARAMS__)', '');
+        }
+        let source$;
+        if (method && method === 'GET') {
+            source$ = this.http.get(providerConfig.baseUrl);
+        }
+        else {
+            source$ = this.http.post(providerConfig.baseUrl, { query: queryBody }, httpOptions);
+        }
+        return source$.pipe(map((response) => response.data[queryName]));
+    }
+    makeParamsStr(params) {
+        const paramsStr = [];
+        Object.keys(params).forEach((key) => {
+            if (Array.isArray(params[key])) {
+                const arrStr = [];
+                params[key].forEach((val) => {
+                    if (typeof val === 'object') {
+                        const subParamsStr = this.makeParamsStr(val);
+                        arrStr.push(`{ ${subParamsStr} }`);
+                    }
+                    else if (typeof val === 'number' || typeof val === 'boolean' || val === null) {
+                        arrStr.push(`${val}`);
+                    }
+                    else {
+                        arrStr.push(`"${val}"`);
+                    }
+                });
+                paramsStr.push(`${key}: [${arrStr.join(',')}]`);
+            }
+            else if (typeof params[key] === 'object' && params[key]) {
+                const subParamsStr = this.makeParamsStr(params[key]);
+                paramsStr.push(`${key}: { ${subParamsStr} }`);
+            }
+            else if (typeof params[key] === 'string' && key.indexOf('$') === 0) {
+                paramsStr.push(`${key.replace('$', '')}: ${params[key]}`);
+            }
+            else if (typeof params[key] === 'number' || typeof params[key] === 'boolean' || params[key] === null) {
+                paramsStr.push(`${key}: ${params[key]}`);
+            }
+            else {
+                paramsStr.push(`${key}: "${params[key]}"`);
+            }
+        });
+        return paramsStr.join(' ');
+    }
+}
+ApolloProvider.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.1", ngImport: i0, type: ApolloProvider, deps: [{ token: i1.HttpClient }, { token: i2.ConfigurationService }], target: i0.ɵɵFactoryTarget.Injectable });
+ApolloProvider.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.2.1", ngImport: i0, type: ApolloProvider, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.1", ngImport: i0, type: ApolloProvider, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.HttpClient }, { type: i2.ConfigurationService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"apollo.provider.js","sourceRoot":"","sources":["../../../../../../projects/n7-boilerplate-common/src/lib/services/communication-providers/apollo.provider.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { HttpClient } from '@angular/common/http';\nimport { map } from 'rxjs/operators';\nimport { Observable } from 'rxjs';\nimport { CommunicationProvider } from './communication-provider.interface';\nimport { ConfigurationService } from '../configuration.service';\n\nconst DEFAULT_TREE_DEPTH = 15;\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class ApolloProvider implements CommunicationProvider {\n  constructor(\n    private http: HttpClient,\n    private configuration: ConfigurationService,\n  ) {}\n\n  request$(providerConfig, requestId: string, options) {\n    const { params, method, httpOptions } = options;\n    const treeDepth = this.configuration.get('treeDepth') || DEFAULT_TREE_DEPTH;\n    const config = providerConfig.config ? providerConfig.config(treeDepth) : {};\n    let query;\n\n    if (config && config[requestId]) {\n      query = config[requestId];\n    }\n\n    query = query || {};\n    const { queryName } = query;\n    let { queryBody } = query;\n\n    // config query control\n    if (!queryName || !queryBody) {\n      throw Error(`No config found for requestId '${requestId}'`);\n    }\n\n    if (params) {\n      const paramsStr = this.makeParamsStr(params);\n      queryBody = queryBody.replace('__PARAMS__', paramsStr);\n    } else {\n      queryBody = queryBody.replace('(__PARAMS__)', '');\n    }\n\n    let source$: Observable<any>;\n\n    if (method && method === 'GET') {\n      source$ = this.http.get(providerConfig.baseUrl);\n    } else {\n      source$ = this.http.post(\n        providerConfig.baseUrl,\n        { query: queryBody },\n        httpOptions,\n      );\n    }\n\n    return source$.pipe(map((response: any) => response.data[queryName]));\n  }\n\n  private makeParamsStr(params) {\n    const paramsStr = [];\n    Object.keys(params).forEach((key) => {\n      if (Array.isArray(params[key])) {\n        const arrStr = [];\n        params[key].forEach((val) => {\n          if (typeof val === 'object') {\n            const subParamsStr = this.makeParamsStr(val);\n            arrStr.push(`{ ${subParamsStr} }`);\n          } else if (typeof val === 'number' || typeof val === 'boolean' || val === null) {\n            arrStr.push(`${val}`);\n          } else {\n            arrStr.push(`\"${val}\"`);\n          }\n        });\n        paramsStr.push(`${key}: [${arrStr.join(',')}]`);\n      } else if (typeof params[key] === 'object' && params[key]) {\n        const subParamsStr = this.makeParamsStr(params[key]);\n        paramsStr.push(`${key}: { ${subParamsStr} }`);\n      } else if (typeof params[key] === 'string' && key.indexOf('$') === 0) {\n        paramsStr.push(`${key.replace('$', '')}: ${params[key]}`);\n      } else if (typeof params[key] === 'number' || typeof params[key] === 'boolean' || params[key] === null) {\n        paramsStr.push(`${key}: ${params[key]}`);\n      } else {\n        paramsStr.push(`${key}: \"${params[key]}\"`);\n      }\n    });\n    return paramsStr.join(' ');\n  }\n}\n"]}

package/esm2020/lib/services/communication-providers/communication-provider.interface.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29tbXVuaWNhdGlvbi1wcm92aWRlci5pbnRlcmZhY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9uNy1ib2lsZXJwbGF0ZS1jb21tb24vc3JjL2xpYi9zZXJ2aWNlcy9jb21tdW5pY2F0aW9uLXByb3ZpZGVycy9jb21tdW5pY2F0aW9uLXByb3ZpZGVyLmludGVyZmFjZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGludGVyZmFjZSBDb21tdW5pY2F0aW9uUHJvdmlkZXIge1xuICByZXF1ZXN0JChcbiAgICBwcm92aWRlckNvbmZpZzogYW55LFxuICAgIHJlcXVlc3RJZDogc3RyaW5nLFxuICAgIG9wdGlvbnM6IGFueVxuICApO1xufVxuIl19

package/esm2020/lib/services/communication-providers/rest.provider.mjs

@@ -0,0 +1,40 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+export class RestProvider {
+    constructor(http) {
+        this.http = http;
+    }
+    request$(providerConfig, requestId, options = {}) {
+        const { params, httpOptions, urlParams = '', } = options;
+        let { method } = options;
+        let point;
+        // default method
+        if (!method) {
+            method = providerConfig.defaultMethod || 'GET';
+        }
+        if (providerConfig.config && providerConfig.config[requestId]) {
+            point = providerConfig.config[requestId];
+        }
+        // config point control
+        if (!point) {
+            throw Error(`No config found for requestId "${requestId}"`);
+        }
+        if (method === 'POST' || method === 'PUT') {
+            return this.http[method.toLowerCase()](providerConfig.baseUrl + point + urlParams, params, httpOptions);
+        }
+        if (method === 'GET' || method === 'DELETE') {
+            return this.http[method.toLowerCase()](providerConfig.baseUrl + point + urlParams, httpOptions);
+        }
+        throw Error(`Rest method ${method} not supported`);
+    }
+}
+RestProvider.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.1", ngImport: i0, type: RestProvider, deps: [{ token: i1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable });
+RestProvider.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.2.1", ngImport: i0, type: RestProvider, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.1", ngImport: i0, type: RestProvider, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.HttpClient }]; } });
+//# sourceMappingURL=data:application/json;base64,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