@ecodev/natural 41.3.0 → 42.2.0

package/esm2020/lib/modules/icon/icon.module.mjs

@@ -0,0 +1,30 @@
+import { CommonModule } from '@angular/common';
+import { NgModule } from '@angular/core';
+import { MatIconModule } from '@angular/material/icon';
+import { IconsConfigService, NaturalIconComponent } from './icon.component';
+import * as i0 from "@angular/core";
+export class NaturalIconModule {
+    static forRoot(config) {
+        return {
+            ngModule: NaturalIconModule,
+            providers: [
+                {
+                    provide: IconsConfigService,
+                    useValue: config,
+                },
+            ],
+        };
+    }
+}
+NaturalIconModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: NaturalIconModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+NaturalIconModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: NaturalIconModule, declarations: [NaturalIconComponent], imports: [CommonModule, MatIconModule], exports: [NaturalIconComponent] });
+NaturalIconModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: NaturalIconModule, imports: [[CommonModule, MatIconModule]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: NaturalIconModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [NaturalIconComponent],
+                    imports: [CommonModule, MatIconModule],
+                    exports: [NaturalIconComponent],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/modules/matomo/matomo-module.module.mjs

@@ -0,0 +1,12 @@
+import { NgModule } from '@angular/core';
+import * as i0 from "@angular/core";
+export class NaturalMatomoModule {
+}
+NaturalMatomoModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: NaturalMatomoModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+NaturalMatomoModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: NaturalMatomoModule });
+NaturalMatomoModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: NaturalMatomoModule });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: NaturalMatomoModule, decorators: [{
+            type: NgModule,
+            args: [{}]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWF0b21vLW1vZHVsZS5tb2R1bGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9uYXR1cmFsL3NyYy9saWIvbW9kdWxlcy9tYXRvbW8vbWF0b21vLW1vZHVsZS5tb2R1bGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFDLFFBQVEsRUFBQyxNQUFNLGVBQWUsQ0FBQzs7QUFHdkMsTUFBTSxPQUFPLG1CQUFtQjs7Z0hBQW5CLG1CQUFtQjtpSEFBbkIsbUJBQW1CO2lIQUFuQixtQkFBbUI7MkZBQW5CLG1CQUFtQjtrQkFEL0IsUUFBUTttQkFBQyxFQUFFIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtOZ01vZHVsZX0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5cbkBOZ01vZHVsZSh7fSlcbmV4cG9ydCBjbGFzcyBOYXR1cmFsTWF0b21vTW9kdWxlIHt9XG4iXX0=

package/esm2020/lib/modules/matomo/matomo.service.mjs

@@ -0,0 +1,105 @@
+import { Inject, Injectable, PLATFORM_ID } from '@angular/core';
+import { NavigationEnd } from '@angular/router';
+import { DOCUMENT, isPlatformBrowser } from '@angular/common';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/router";
+import * as i2 from "@angular/platform-browser";
+/**
+ * Service to track visitors via Matomo.
+ *
+ * @dynamic
+ */
+export class NaturalMatomoService {
+    constructor(router, document, 
+    // eslint-disable-next-line @typescript-eslint/ban-types
+    platformId, titleService) {
+        this.router = router;
+        this.document = document;
+        this.platformId = platformId;
+        this.titleService = titleService;
+        this.subscription = null;
+        this.referrerUrl = '';
+        this.isBrowser = isPlatformBrowser(platformId);
+        const window = this.document.defaultView;
+        if (!window) {
+            throw new Error('Could not init MatomoService `window` is undefined');
+        }
+        this.window = window;
+    }
+    /**
+     * Inject Matomo script and start tracking all page navigation
+     */
+    startTracking(url, site) {
+        // Abort because no tracking info or doing SSR
+        if (!url || !site || !this.isBrowser) {
+            return;
+        }
+        this.push('setTrackerUrl', url + '/matomo.php');
+        this.push('setSiteId', site);
+        this.injectTrackingCode(url);
+        this.listenForRouteChanges();
+    }
+    stopTracking() {
+        this.subscription?.unsubscribe();
+        this.subscription = null;
+        delete this.window._paq;
+    }
+    /**
+     * Push a Matomo command on the stack
+     *
+     * It can be called at any time, including before Matomo is even loaded.
+     *
+     * Also see https://developer.matomo.org/guides/tracking-javascript-guide
+     */
+    push(functionName, ...args) {
+        if (!this.window._paq) {
+            this.window._paq = [];
+        }
+        // Here we must always get `_paq` freshly from window, because Matomo
+        // might have changed the object after we created it
+        this.window._paq.push([functionName, ...args]);
+    }
+    injectTrackingCode(url) {
+        try {
+            const script = this.document.createElement('script');
+            script.async = true;
+            script.defer = true;
+            script.src = url + '/matomo.js';
+            this.document.head.appendChild(script);
+        }
+        catch (ex) {
+            console.error('Error appending Matomo analytics');
+            console.error(ex);
+        }
+    }
+    listenForRouteChanges() {
+        this.subscription = this.router.events.subscribe(event => {
+            if (!(event instanceof NavigationEnd)) {
+                return;
+            }
+            const currentUrl = this.window.location.href;
+            this.push('setCustomUrl', currentUrl);
+            this.push('setDocumentTitle', this.titleService.getTitle());
+            if (this.referrerUrl) {
+                this.push('setReferrerUrl', this.referrerUrl);
+            }
+            this.push('trackPageView');
+            this.referrerUrl = currentUrl;
+        });
+    }
+}
+NaturalMatomoService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: NaturalMatomoService, deps: [{ token: i1.Router }, { token: DOCUMENT }, { token: PLATFORM_ID }, { token: i2.Title }], target: i0.ɵɵFactoryTarget.Injectable });
+NaturalMatomoService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: NaturalMatomoService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: NaturalMatomoService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.Router }, { type: Document, decorators: [{
+                    type: Inject,
+                    args: [DOCUMENT]
+                }] }, { type: Object, decorators: [{
+                    type: Inject,
+                    args: [PLATFORM_ID]
+                }] }, { type: i2.Title }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"matomo.service.js","sourceRoot":"","sources":["../../../../../../projects/natural/src/lib/modules/matomo/matomo.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {Inject, Injectable, PLATFORM_ID} from '@angular/core';\nimport {NavigationEnd, Router} from '@angular/router';\nimport {DOCUMENT, isPlatformBrowser} from '@angular/common';\nimport {Subscription} from 'rxjs';\nimport {Title} from '@angular/platform-browser';\n\n/**\n * Incomplete list of Matomo functions. But it should be enough\n * for our basic needs.\n *\n * To complete this list, maybe see https://developer.matomo.org/guides/tracking-javascript-guide\n */\ntype MatomoFunction =\n    | 'setCustomUrl'\n    | 'setCustomVariable'\n    | 'setDocumentTitle'\n    | 'setReferrerUrl'\n    | 'setSiteId'\n    | 'setTrackerUrl'\n    | 'trackPageView';\n\nexport type PaqItem = [MatomoFunction, ...(number | string | null)[]];\n\ninterface Paq {\n    push: (item: PaqItem) => void;\n}\n\n/**\n * Service to track visitors via Matomo.\n *\n * @dynamic\n */\n@Injectable({\n    providedIn: 'root',\n})\nexport class NaturalMatomoService {\n    private subscription: Subscription | null = null;\n    private readonly isBrowser: boolean;\n    private readonly window: WindowProxy & typeof globalThis & {_paq?: Paq};\n    private referrerUrl = '';\n\n    public constructor(\n        private readonly router: Router,\n        @Inject(DOCUMENT) private readonly document: Document,\n        // eslint-disable-next-line @typescript-eslint/ban-types\n        @Inject(PLATFORM_ID) public readonly platformId: Object,\n        private readonly titleService: Title,\n    ) {\n        this.isBrowser = isPlatformBrowser(platformId);\n        const window = this.document.defaultView;\n        if (!window) {\n            throw new Error('Could not init MatomoService `window` is undefined');\n        }\n\n        this.window = window;\n    }\n\n    /**\n     * Inject Matomo script and start tracking all page navigation\n     */\n    public startTracking(url: string | null, site: number | null): void {\n        // Abort because no tracking info or doing SSR\n        if (!url || !site || !this.isBrowser) {\n            return;\n        }\n\n        this.push('setTrackerUrl', url + '/matomo.php');\n        this.push('setSiteId', site);\n\n        this.injectTrackingCode(url);\n        this.listenForRouteChanges();\n    }\n\n    public stopTracking(): void {\n        this.subscription?.unsubscribe();\n        this.subscription = null;\n        delete this.window._paq;\n    }\n\n    /**\n     * Push a Matomo command on the stack\n     *\n     * It can be called at any time, including before Matomo is even loaded.\n     *\n     * Also see https://developer.matomo.org/guides/tracking-javascript-guide\n     */\n    public push(functionName: PaqItem[0], ...args: PaqItem[1][]): void {\n        if (!this.window._paq) {\n            this.window._paq = [] as any[];\n        }\n\n        // Here we must always get `_paq` freshly from window, because Matomo\n        // might have changed the object after we created it\n        this.window._paq.push([functionName, ...args]);\n    }\n\n    private injectTrackingCode(url: string): void {\n        try {\n            const script = this.document.createElement('script');\n            script.async = true;\n            script.defer = true;\n            script.src = url + '/matomo.js';\n            this.document.head.appendChild(script);\n        } catch (ex) {\n            console.error('Error appending Matomo analytics');\n            console.error(ex);\n        }\n    }\n\n    private listenForRouteChanges(): void {\n        this.subscription = this.router.events.subscribe(event => {\n            if (!(event instanceof NavigationEnd)) {\n                return;\n            }\n\n            const currentUrl = this.window.location.href;\n\n            this.push('setCustomUrl', currentUrl);\n            this.push('setDocumentTitle', this.titleService.getTitle());\n            if (this.referrerUrl) {\n                this.push('setReferrerUrl', this.referrerUrl);\n            }\n\n            this.push('trackPageView');\n\n            this.referrerUrl = currentUrl;\n        });\n    }\n}\n"]}

package/esm2020/lib/modules/panels/abstract-panel.mjs

@@ -0,0 +1,56 @@
+import { Directive, HostBinding, HostListener } from '@angular/core';
+import { merge } from 'lodash-es';
+import { NaturalAbstractController } from '../../classes/abstract-controller';
+import * as i0 from "@angular/core";
+export class NaturalAbstractPanel extends NaturalAbstractController {
+    constructor() {
+        super(...arguments);
+        /**
+         * The data property is the container where the resolved content is stored
+         * When loading a component from a panel opening (dialog), receives the data provided by the service
+         */
+        this.data = {};
+        /**
+         * Bind isFrontPanel style class on root component
+         */
+        this.isFrontPanel = false;
+        /**
+         * Bind isPanel style class on root component
+         */
+        this.isPanel = false;
+    }
+    /**
+     * Bind click on panels, to allow the selection of those who are behind
+     */
+    clickPanel() {
+        if (!this.isFrontPanel && this.panelService) {
+            this.panelService.goToPanelByComponent(this);
+        }
+    }
+    /**
+     * Called when panel opens and component is loaded
+     * Runs before ngOnInit()
+     */
+    initPanel(panelData) {
+        this.panelData = panelData;
+        this.isPanel = true;
+        if (this.panelData && this.panelData.data) {
+            merge(this.data, this.panelData.data);
+        }
+    }
+}
+NaturalAbstractPanel.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: NaturalAbstractPanel, deps: null, target: i0.ɵɵFactoryTarget.Directive });
+NaturalAbstractPanel.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.3.0", type: NaturalAbstractPanel, host: { listeners: { "click": "clickPanel()" }, properties: { "class.isFrontPanel": "this.isFrontPanel", "class.isPanel": "this.isPanel" } }, usesInheritance: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: NaturalAbstractPanel, decorators: [{
+            type: Directive
+        }], propDecorators: { isFrontPanel: [{
+                type: HostBinding,
+                args: ['class.isFrontPanel']
+            }], isPanel: [{
+                type: HostBinding,
+                args: ['class.isPanel']
+            }], clickPanel: [{
+                type: HostListener,
+                args: ['click']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/modules/panels/panels.component.mjs

@@ -0,0 +1,26 @@
+import { Component } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "./panels.service";
+import * as i2 from "@angular/router";
+export class NaturalPanelsComponent {
+    // PanelsComponent is kind of a "ghost" component to respond to an url matcher in route config,
+    // An UrlMatcher (matcher attribute) is required to catch urls with an undefined number of params in url after a given param /panels/
+    constructor(panelsService, route) {
+        this.panelsService = panelsService;
+        this.route = route;
+        this.panelsService.start(route);
+    }
+    ngOnDestroy() {
+        this.panelsService.stop();
+    }
+}
+NaturalPanelsComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: NaturalPanelsComponent, deps: [{ token: i1.NaturalPanelsService }, { token: i2.ActivatedRoute }], target: i0.ɵɵFactoryTarget.Component });
+NaturalPanelsComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.3.0", type: NaturalPanelsComponent, selector: "natural-panels", ngImport: i0, template: '', isInline: true });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: NaturalPanelsComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'natural-panels',
+                    template: '',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.NaturalPanelsService }, { type: i2.ActivatedRoute }]; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGFuZWxzLmNvbXBvbmVudC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL25hdHVyYWwvc3JjL2xpYi9tb2R1bGVzL3BhbmVscy9wYW5lbHMuY29tcG9uZW50LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBQyxTQUFTLEVBQVksTUFBTSxlQUFlLENBQUM7Ozs7QUFRbkQsTUFBTSxPQUFPLHNCQUFzQjtJQUMvQiwrRkFBK0Y7SUFDL0YscUlBQXFJO0lBQ3JJLFlBQW9DLGFBQW1DLEVBQW1CLEtBQXFCO1FBQTNFLGtCQUFhLEdBQWIsYUFBYSxDQUFzQjtRQUFtQixVQUFLLEdBQUwsS0FBSyxDQUFnQjtRQUMzRyxJQUFJLENBQUMsYUFBYSxDQUFDLEtBQUssQ0FBQyxLQUFLLENBQUMsQ0FBQztJQUNwQyxDQUFDO0lBRU0sV0FBVztRQUNkLElBQUksQ0FBQyxhQUFhLENBQUMsSUFBSSxFQUFFLENBQUM7SUFDOUIsQ0FBQzs7bUhBVFEsc0JBQXNCO3VHQUF0QixzQkFBc0Isc0RBRnJCLEVBQUU7MkZBRUgsc0JBQXNCO2tCQUpsQyxTQUFTO21CQUFDO29CQUNQLFFBQVEsRUFBRSxnQkFBZ0I7b0JBQzFCLFFBQVEsRUFBRSxFQUFFO2lCQUNmIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtDb21wb25lbnQsIE9uRGVzdHJveX0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQge0FjdGl2YXRlZFJvdXRlfSBmcm9tICdAYW5ndWxhci9yb3V0ZXInO1xuaW1wb3J0IHtOYXR1cmFsUGFuZWxzU2VydmljZX0gZnJvbSAnLi9wYW5lbHMuc2VydmljZSc7XG5cbkBDb21wb25lbnQoe1xuICAgIHNlbGVjdG9yOiAnbmF0dXJhbC1wYW5lbHMnLFxuICAgIHRlbXBsYXRlOiAnJyxcbn0pXG5leHBvcnQgY2xhc3MgTmF0dXJhbFBhbmVsc0NvbXBvbmVudCBpbXBsZW1lbnRzIE9uRGVzdHJveSB7XG4gICAgLy8gUGFuZWxzQ29tcG9uZW50IGlzIGtpbmQgb2YgYSBcImdob3N0XCIgY29tcG9uZW50IHRvIHJlc3BvbmQgdG8gYW4gdXJsIG1hdGNoZXIgaW4gcm91dGUgY29uZmlnLFxuICAgIC8vIEFuIFVybE1hdGNoZXIgKG1hdGNoZXIgYXR0cmlidXRlKSBpcyByZXF1aXJlZCB0byBjYXRjaCB1cmxzIHdpdGggYW4gdW5kZWZpbmVkIG51bWJlciBvZiBwYXJhbXMgaW4gdXJsIGFmdGVyIGEgZ2l2ZW4gcGFyYW0gL3BhbmVscy9cbiAgICBwdWJsaWMgY29uc3RydWN0b3IocHJpdmF0ZSByZWFkb25seSBwYW5lbHNTZXJ2aWNlOiBOYXR1cmFsUGFuZWxzU2VydmljZSwgcHJpdmF0ZSByZWFkb25seSByb3V0ZTogQWN0aXZhdGVkUm91dGUpIHtcbiAgICAgICAgdGhpcy5wYW5lbHNTZXJ2aWNlLnN0YXJ0KHJvdXRlKTtcbiAgICB9XG5cbiAgICBwdWJsaWMgbmdPbkRlc3Ryb3koKTogdm9pZCB7XG4gICAgICAgIHRoaXMucGFuZWxzU2VydmljZS5zdG9wKCk7XG4gICAgfVxufVxuIl19

package/esm2020/lib/modules/panels/panels.module.mjs

@@ -0,0 +1,33 @@
+import { CommonModule } from '@angular/common';
+import { NgModule } from '@angular/core';
+import { MatDialogModule } from '@angular/material/dialog';
+import { RouterModule } from '@angular/router';
+import { NaturalPanelsComponent } from './panels.component';
+import { PanelsHooksConfig } from './types';
+import * as i0 from "@angular/core";
+const declarations = [NaturalPanelsComponent];
+export class NaturalPanelsModule {
+    static forRoot(hooks) {
+        return {
+            ngModule: NaturalPanelsModule,
+            providers: [
+                {
+                    provide: PanelsHooksConfig,
+                    useValue: hooks,
+                },
+            ],
+        };
+    }
+}
+NaturalPanelsModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: NaturalPanelsModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+NaturalPanelsModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: NaturalPanelsModule, declarations: [NaturalPanelsComponent], imports: [CommonModule, RouterModule, MatDialogModule], exports: [NaturalPanelsComponent] });
+NaturalPanelsModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: NaturalPanelsModule, imports: [[CommonModule, RouterModule, MatDialogModule]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: NaturalPanelsModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: declarations,
+                    imports: [CommonModule, RouterModule, MatDialogModule],
+                    exports: declarations,
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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