@design-factory/design-factory 15.2.0

package/esm2022/lib/angular/sidenav/sidenav-config.mjs

@@ -0,0 +1,25 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * A configuration service for the [DfSideNavService](#/components/sidenav/api#DfSideNavComponent) component.
+ *
+ * You can inject this service, typically in your root component, and customize its properties
+ * to provide default values for your sidenav used in the application.
+ */
+export class DfSideNavConfig {
+    constructor() {
+        this.isMinmized = false;
+        this.isCollapsed = false;
+        this.isPresent = false;
+        this.isInMenuOverlay = true;
+        this.isAppOverlay = false;
+        this.isAppOverlayMode = true;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: DfSideNavConfig, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: DfSideNavConfig, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: DfSideNavConfig, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2lkZW5hdi1jb25maWcuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9kZXNpZ24tZmFjdG9yeS9zcmMvbGliL2FuZ3VsYXIvc2lkZW5hdi9zaWRlbmF2LWNvbmZpZy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sZUFBZSxDQUFDOztBQUUzQzs7Ozs7R0FLRztBQUVILE1BQU0sT0FBTyxlQUFlO0lBRDVCO1FBRUUsZUFBVSxHQUFHLEtBQUssQ0FBQztRQUNuQixnQkFBVyxHQUFHLEtBQUssQ0FBQztRQUNwQixjQUFTLEdBQUcsS0FBSyxDQUFDO1FBQ2xCLG9CQUFlLEdBQUcsSUFBSSxDQUFDO1FBQ3ZCLGlCQUFZLEdBQUcsS0FBSyxDQUFDO1FBQ3JCLHFCQUFnQixHQUFHLElBQUksQ0FBQztLQUN6Qjs4R0FQWSxlQUFlO2tIQUFmLGVBQWUsY0FERixNQUFNOzsyRkFDbkIsZUFBZTtrQkFEM0IsVUFBVTttQkFBQyxFQUFFLFVBQVUsRUFBRSxNQUFNLEVBQUUiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJbmplY3RhYmxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5cbi8qKlxuICogQSBjb25maWd1cmF0aW9uIHNlcnZpY2UgZm9yIHRoZSBbRGZTaWRlTmF2U2VydmljZV0oIy9jb21wb25lbnRzL3NpZGVuYXYvYXBpI0RmU2lkZU5hdkNvbXBvbmVudCkgY29tcG9uZW50LlxuICpcbiAqIFlvdSBjYW4gaW5qZWN0IHRoaXMgc2VydmljZSwgdHlwaWNhbGx5IGluIHlvdXIgcm9vdCBjb21wb25lbnQsIGFuZCBjdXN0b21pemUgaXRzIHByb3BlcnRpZXNcbiAqIHRvIHByb3ZpZGUgZGVmYXVsdCB2YWx1ZXMgZm9yIHlvdXIgc2lkZW5hdiB1c2VkIGluIHRoZSBhcHBsaWNhdGlvbi5cbiAqL1xuQEluamVjdGFibGUoeyBwcm92aWRlZEluOiAncm9vdCcgfSlcbmV4cG9ydCBjbGFzcyBEZlNpZGVOYXZDb25maWcge1xuICBpc01pbm1pemVkID0gZmFsc2U7XG4gIGlzQ29sbGFwc2VkID0gZmFsc2U7XG4gIGlzUHJlc2VudCA9IGZhbHNlO1xuICBpc0luTWVudU92ZXJsYXkgPSB0cnVlO1xuICBpc0FwcE92ZXJsYXkgPSBmYWxzZTtcbiAgaXNBcHBPdmVybGF5TW9kZSA9IHRydWU7XG59XG4iXX0=

package/esm2022/lib/angular/sidenav/sidenav.component.mjs

@@ -0,0 +1,86 @@
+import { Component, ContentChild, Directive, HostBinding, inject } from '@angular/core';
+import { Subscription } from 'rxjs';
+import { DfSideNavService } from './sidenav.service';
+import { CommonModule } from '@angular/common';
+import { DfSideNavListComponent } from './sidenavlist.component';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+export class DfSideNavHeaderDirective {
+    constructor(templateRef) {
+        this.templateRef = templateRef;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: DfSideNavHeaderDirective, deps: [{ token: i0.TemplateRef }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.1.4", type: DfSideNavHeaderDirective, isStandalone: true, selector: "ng-template[dfSideNavHeader]", ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: DfSideNavHeaderDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: 'ng-template[dfSideNavHeader]', standalone: true }]
+        }], ctorParameters: function () { return [{ type: i0.TemplateRef }]; } });
+export class DfSideNavIconDirective {
+    constructor(templateRef) {
+        this.templateRef = templateRef;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: DfSideNavIconDirective, deps: [{ token: i0.TemplateRef }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.1.4", type: DfSideNavIconDirective, isStandalone: true, selector: "ng-template[dfSideNavIcon]", ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: DfSideNavIconDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: 'ng-template[dfSideNavIcon]', standalone: true }]
+        }], ctorParameters: function () { return [{ type: i0.TemplateRef }]; } });
+export class DfSideNavItemDirective {
+    constructor(templateRef) {
+        this.templateRef = templateRef;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: DfSideNavItemDirective, deps: [{ token: i0.TemplateRef }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.1.4", type: DfSideNavItemDirective, isStandalone: true, selector: "ng-template[dfSideNavItem]", ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: DfSideNavItemDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: 'ng-template[dfSideNavItem]', standalone: true }]
+        }], ctorParameters: function () { return [{ type: i0.TemplateRef }]; } });
+/**
+ * SideNav is a component to provide navigation feature with a panel on the side of your page
+ *
+ * It supports several options as:
+ *  - Being in an overlay menu or not
+ *  - Being collapsed or not
+ *  - Can be used with or without Angular Router
+ *  - Can be used with media queries to adjust behavior to different breakpoints (see media section)
+ */
+export class DfSideNavComponent {
+    constructor() {
+        this.elements = 'df-sidenav-light d-flex flex-column flex-shrink-0';
+        this.subscription = new Subscription();
+        this.sideNavService = inject(DfSideNavService);
+        this.subscription.add(this.sideNavService.isInMenuOverlay$.subscribe((value) => {
+            this.overlayClass = value;
+        }));
+        setTimeout(() => this.sideNavService.setSideNav());
+    }
+    ngOnDestroy() {
+        this.subscription.unsubscribe();
+        this.sideNavService.removeSideBar();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: DfSideNavComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.1.4", type: DfSideNavComponent, isStandalone: true, selector: "df-sidenav", host: { properties: { "class.df-sidenav-menu-overlay": "this.overlayClass", "class": "this.elements" } }, queries: [{ propertyName: "tplHeader", first: true, predicate: DfSideNavHeaderDirective, descendants: true }, { propertyName: "tplIcon", first: true, predicate: DfSideNavIconDirective, descendants: true }, { propertyName: "tplItem", first: true, predicate: DfSideNavItemDirective, descendants: true }], ngImport: i0, template: "<ng-template *ngIf=\"tplHeader\" [ngTemplateOutlet]=\"tplHeader.templateRef\"></ng-template>\n<df-sidenavlist [items]=\"(sideNavService.sideNavItems$ | async) ?? []\" [tplIcon]=\"tplIcon\" [tplItem]=\"tplItem\"></df-sidenavlist>\n", dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: i1.NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }, { kind: "pipe", type: i1.AsyncPipe, name: "async" }, { kind: "component", type: DfSideNavListComponent, selector: "df-sidenavlist", inputs: ["items", "tplIcon", "tplItem", "currentItem", "id"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: DfSideNavComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'df-sidenav', standalone: true, imports: [CommonModule, DfSideNavListComponent], template: "<ng-template *ngIf=\"tplHeader\" [ngTemplateOutlet]=\"tplHeader.templateRef\"></ng-template>\n<df-sidenavlist [items]=\"(sideNavService.sideNavItems$ | async) ?? []\" [tplIcon]=\"tplIcon\" [tplItem]=\"tplItem\"></df-sidenavlist>\n" }]
+        }], ctorParameters: function () { return []; }, propDecorators: { tplHeader: [{
+                type: ContentChild,
+                args: [DfSideNavHeaderDirective, { static: false }]
+            }], tplIcon: [{
+                type: ContentChild,
+                args: [DfSideNavIconDirective, { static: false }]
+            }], tplItem: [{
+                type: ContentChild,
+                args: [DfSideNavItemDirective, { static: false }]
+            }], overlayClass: [{
+                type: HostBinding,
+                args: ['class.df-sidenav-menu-overlay']
+            }], elements: [{
+                type: HostBinding,
+                args: ['class']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/angular/sidenav/sidenav.module.mjs

@@ -0,0 +1,52 @@
+import { NgModule } from '@angular/core';
+import { DfSideNavComponent, DfSideNavHeaderDirective, DfSideNavIconDirective, DfSideNavItemDirective } from './sidenav.component';
+import { DfManageSideNavDirective } from './manage-sidenav.directive';
+import { DfMediaModule } from '../mediaqueries/media.module';
+import { DfSideNavCollapseModule } from './dfSideNavCollapse.module';
+import { DfExcludeTrapDirective } from '../sidenav/excludeTrap.directive';
+import * as i0 from "@angular/core";
+export { DfSideNavComponent, DfSideNavHeaderDirective, DfSideNavIconDirective, DfSideNavItemDirective } from './sidenav.component';
+export { DfManageSideNavDirective } from './manage-sidenav.directive';
+export { DfExcludeTrapDirective } from '../sidenav/excludeTrap.directive';
+export class DfSideNavModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: DfSideNavModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "16.1.4", ngImport: i0, type: DfSideNavModule, imports: [DfManageSideNavDirective,
+            DfSideNavComponent,
+            DfSideNavHeaderDirective,
+            DfExcludeTrapDirective,
+            DfSideNavIconDirective,
+            DfSideNavItemDirective], exports: [DfManageSideNavDirective,
+            DfSideNavComponent,
+            DfSideNavHeaderDirective,
+            DfExcludeTrapDirective,
+            DfSideNavIconDirective,
+            DfSideNavItemDirective,
+            DfSideNavCollapseModule,
+            DfMediaModule] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: DfSideNavModule, imports: [DfSideNavComponent, DfSideNavCollapseModule,
+            DfMediaModule] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: DfSideNavModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        DfManageSideNavDirective,
+                        DfSideNavComponent,
+                        DfSideNavHeaderDirective,
+                        DfExcludeTrapDirective,
+                        DfSideNavIconDirective,
+                        DfSideNavItemDirective
+                    ],
+                    exports: [
+                        DfManageSideNavDirective,
+                        DfSideNavComponent,
+                        DfSideNavHeaderDirective,
+                        DfExcludeTrapDirective,
+                        DfSideNavIconDirective,
+                        DfSideNavItemDirective,
+                        DfSideNavCollapseModule,
+                        DfMediaModule
+                    ]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/angular/sidenav/sidenav.service.mjs

@@ -0,0 +1,315 @@
+import { Injectable } from '@angular/core';
+import { BehaviorSubject, Subscription } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "./sidenav-config";
+export var DfNavItemType;
+(function (DfNavItemType) {
+    DfNavItemType[DfNavItemType["subMenus"] = 0] = "subMenus";
+    DfNavItemType[DfNavItemType["actionButton"] = 1] = "actionButton";
+    DfNavItemType[DfNavItemType["routerLink"] = 2] = "routerLink";
+    DfNavItemType[DfNavItemType["link"] = 3] = "link";
+    DfNavItemType[DfNavItemType["externalLink"] = 4] = "externalLink";
+    DfNavItemType[DfNavItemType["separator"] = 5] = "separator";
+    DfNavItemType[DfNavItemType["template"] = 6] = "template";
+    DfNavItemType[DfNavItemType["title"] = 7] = "title";
+})(DfNavItemType || (DfNavItemType = {}));
+/**
+ * A service for managing the sidenav panel.
+ * This service is included at root level
+ *
+ * Creating a sidenav is straightforward: use [DfSideNavComponent](#/components/sidenav/api#DfSideNavComponent) component
+ */
+export class DfSideNavService {
+    constructor(config) {
+        this.type = DfNavItemType;
+        this._items = [];
+        this.subscription = new Subscription();
+        this._sideNavItems$ = new BehaviorSubject([]);
+        this._isMinmized$ = new BehaviorSubject(config.isMinmized);
+        this._isCollapsed$ = new BehaviorSubject(config.isCollapsed);
+        this._isPresent$ = new BehaviorSubject(config.isPresent);
+        this._isInMenuOverlay$ = new BehaviorSubject(config.isInMenuOverlay);
+        this._isAppOverlay$ = new BehaviorSubject(config.isAppOverlay);
+        this._activeItem$ = new BehaviorSubject(null);
+        this._isAppOverlayMode = config.isAppOverlayMode;
+        this.subscription.add(this._isCollapsed$.subscribe(() => {
+            this.updateOverLay();
+        }));
+    }
+    ngOnDestroy() {
+        this.subscription.unsubscribe();
+    }
+    /**
+     * Use this to init the list of Elements from your sidenav
+     *
+     *
+     * Second option withRouter is to be set to false if you are not passing link string for the angular Router
+     * Here we are not deep copying the array --> the function will change it
+     */
+    initItems(items, withRouter = true) {
+        this._items = items;
+        this.addNavItemType(withRouter);
+        this.setActiveItem(this._items);
+        this.dispatchSideNavItems();
+    }
+    /**
+     * Use this to inactivate the list of Elements from your sidenav
+     * isActive properties of all items will be set to false recursively
+     *
+     */
+    inactiveItems(list) {
+        list.forEach(item => {
+            item.isActive = false;
+            if (item.subMenus) {
+                this.inactiveItems(item.subMenus);
+            }
+        });
+        this.dispatchSideNavItems();
+    }
+    /**
+     * Use this to active the item pass as input
+     * This function inactivate all the other items of the service
+     * It will then dispatch the list of items of the sideNav to activeItem$
+     *
+     */
+    activeItem(item) {
+        this.inactiveItems(this._items);
+        item.isActive = true;
+        this._activeItem$.next(item);
+        this.dispatchSideNavItems();
+    }
+    /**
+     * Getter to know when to put/remove the overlay.
+     * `True` in case of overlay needed
+     *
+     */
+    get isAppOverlay$() {
+        return this._isAppOverlay$.asObservable();
+    }
+    /**
+     * Getter to know if the sidenav is in an overlay panel or not
+     * `True` in case of overlay panel
+     *
+     */
+    get isInMenuOverlay$() {
+        return this._isInMenuOverlay$.asObservable();
+    }
+    /**
+     * Getter to know the current activeItem a user clicked on
+     *
+     */
+    get activeItem$() {
+        return this._activeItem$.asObservable();
+    }
+    /**
+     * Getter to know if the sideNav is present in the page
+     * SideNav may be collapsed here or not
+     *
+     */
+    get isPresent$() {
+        return this._isPresent$.asObservable();
+    }
+    /**
+     * Future Options
+     */
+    get isMinimized$() {
+        return this._isMinmized$.asObservable();
+    }
+    /**
+     * Getter to know if the SideNav is collapsed or not
+     * If `true` the SideNav is collapsed
+     *
+     */
+    get isCollapsed$() {
+        return this._isCollapsed$.asObservable();
+    }
+    /**
+     * Getter of the SideNav Items after they have beens changed
+     *
+     */
+    get sideNavItems$() {
+        return this._sideNavItems$.asObservable();
+    }
+    /**
+     * Getter to know the mode Apply for the SideNav
+     * If `true` the SideNav can be in overlay (but not necessary is).
+     *
+     */
+    get isAppOverlayMode() {
+        return this._isAppOverlayMode;
+    }
+    // initItems must be used to push new items to the service
+    get items() {
+        return this._items;
+    }
+    /**
+     * Use this to toggle a SideNav Item (either from expand to collapse or the other way around).
+     * isCollapsed attribute of the input item is changed.
+     * All items are push again to the stream of items.
+     * This is used internally by the SideNav in case of click and Enter on an Item with subMenus
+     */
+    toggle(itemInput) {
+        itemInput.isCollapsed = !itemInput.isCollapsed;
+        this.dispatchSideNavItems();
+    }
+    /**
+     *
+     * @param itemInput
+     */
+    collapseItem(itemInput) {
+        this.collapse(itemInput, this._items);
+        this.dispatchSideNavItems();
+    }
+    /**
+     * Use this to collapseAll items
+     */
+    collapseAllItems() {
+        this.collapseAll(this._items);
+        this.dispatchSideNavItems();
+    }
+    /**
+     * Use this to set/unset the SideNav in an Overlay Menu
+     * If input is `True` then the SideNav will be in an Overlay Menu
+     * (when not collapsed)
+     *
+     */
+    setInMenuSideNav(on) {
+        this._isInMenuOverlay$.next(on);
+    }
+    /**
+     * Use this to collapse the SideNav
+     *
+     */
+    hideSideNav() {
+        this._isCollapsed$.next(true);
+    }
+    /**
+     * Use this to make the SideNav visible (uncollapse)
+     *
+     */
+    showSideNav() {
+        this._isCollapsed$.next(false);
+    }
+    /**
+     * Use this to toggle the SideNav status collapse/visible
+     *
+     */
+    toggleSideNav() {
+        this._isCollapsed$.next(!this._isCollapsed$.value);
+    }
+    // internal usage from the SideNav. Call when component is destroy
+    removeSideBar() {
+        this._isCollapsed$.next(false);
+        this._isPresent$.next(false);
+    }
+    /**
+     * Use this to set the App Overlay Mode
+     * Input `True` if you want to set the AppOverlay
+     * An event is send to isAppOverlay$ depending on your status
+     * if Input = `True` and isCollapsed = `False` then isAppOverlay$
+     * will be `True`
+     *
+     */
+    setAppOverlayMode(on) {
+        this._isAppOverlayMode = on;
+        this.updateOverLay();
+    }
+    // Internal usage to the sidenav component
+    // Do not use
+    setSideNav() {
+        this._isPresent$.next(true);
+    }
+    /**
+     *
+     * @param itemInput
+     * @param itemsList
+     */
+    collapse(itemInput, itemsList) {
+        for (const item of itemsList) {
+            if (item === itemInput && item.subMenus) {
+                item.isCollapsed = true;
+                return true; // propagate the collapse up
+            }
+            else if (item === itemInput) {
+                return true;
+            }
+            else if (item.subMenus) {
+                const needcol = this.collapse(itemInput, item.subMenus);
+                if (needcol) {
+                    item.isCollapsed = true; // collapse it
+                    return true; // propagate the collapse up
+                }
+            }
+        }
+        return false;
+    }
+    /**
+     *
+     * @param itemsList
+     */
+    collapseAll(itemsList) {
+        itemsList.forEach(item => {
+            if (item.subMenus) {
+                item.isCollapsed = true;
+                this.collapseAll(item.subMenus);
+            }
+        });
+    }
+    // Only one item at the time must be active
+    // Active flag in item is only valid for action button and link
+    // Router link does not use this active flag to work
+    // It is up to you to inactivateItems when needed when you mix actionButton and router link
+    // To avoid more than one active state visible
+    setActiveItem(items, foundAnActive = false) {
+        let foundActive = foundAnActive;
+        items.forEach(item => {
+            if (item.isActive && foundAnActive) {
+                throw Error('DfSideNavService must be init with only one isActive item');
+            }
+            else if (item.isActive) {
+                this._activeItem$.next(item);
+                foundActive = true;
+            }
+            if (item.subMenus) {
+                foundActive = this.setActiveItem(item.subMenus, foundActive);
+            }
+        });
+        return foundActive;
+    }
+    addNavItemType(withRouter, items = this._items) {
+        items.forEach(item => {
+            if (!item.type) {
+                if (item.subMenus) {
+                    item.type = DfNavItemType.subMenus;
+                }
+                else if (item.isExternal) {
+                    item.type = DfNavItemType.externalLink;
+                }
+                else if (withRouter) {
+                    item.type = DfNavItemType.routerLink;
+                }
+                else {
+                    item.type = DfNavItemType.actionButton;
+                }
+            }
+            if (item.subMenus) {
+                this.addNavItemType(withRouter, item.subMenus);
+            }
+        });
+    }
+    dispatchSideNavItems() {
+        this._sideNavItems$.next(this._items);
+    }
+    updateOverLay() {
+        this._isAppOverlay$.next(this.isAppOverlayMode && this._isCollapsed$.value === false);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: DfSideNavService, deps: [{ token: i1.DfSideNavConfig }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: DfSideNavService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: DfSideNavService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.DfSideNavConfig }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sidenav.service.js","sourceRoot":"","sources":["../../../../../../projects/design-factory/src/lib/angular/sidenav/sidenav.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, OnDestroy, TemplateRef } from '@angular/core';\nimport { BehaviorSubject, Observable, Subscription } from 'rxjs';\nimport { DfSideNavConfig } from './sidenav-config';\n\nexport interface DfSideNavItem {\n  value: string;\n  title?: string;\n  icon?: string | TemplateRef<any>;\n  isExternal?: boolean;\n  isActive?: boolean;\n  isCollapsed?: boolean;\n  breakpoints?: string[];\n  subMenus?: DfSideNavItem[];\n  type?: DfNavItemType;\n}\n\nexport enum DfNavItemType {\n  subMenus,\n  actionButton,\n  routerLink,\n  link,\n  externalLink,\n  separator,\n  template,\n  title\n}\n\n/**\n * A service for managing the sidenav panel.\n * This service is included at root level\n *\n * Creating a sidenav is straightforward: use [DfSideNavComponent](#/components/sidenav/api#DfSideNavComponent) component\n */\n@Injectable({\n  providedIn: 'root'\n})\nexport class DfSideNavService implements OnDestroy {\n  public type = DfNavItemType;\n  private readonly _sideNavItems$;\n  private readonly _isMinmized$;\n  private readonly _isCollapsed$;\n  private readonly _isPresent$;\n  private readonly _activeItem$;\n  private readonly _isInMenuOverlay$;\n  private readonly _isAppOverlay$;\n  private _isAppOverlayMode;\n  private _items: DfSideNavItem[] = [];\n  private readonly subscription: Subscription = new Subscription();\n\n  constructor(config: DfSideNavConfig) {\n    this._sideNavItems$ = new BehaviorSubject<DfSideNavItem[]>([]);\n    this._isMinmized$ = new BehaviorSubject<boolean>(config.isMinmized);\n    this._isCollapsed$ = new BehaviorSubject<boolean>(config.isCollapsed);\n    this._isPresent$ = new BehaviorSubject<boolean>(config.isPresent);\n    this._isInMenuOverlay$ = new BehaviorSubject<boolean>(config.isInMenuOverlay);\n    this._isAppOverlay$ = new BehaviorSubject<boolean>(config.isAppOverlay);\n    this._activeItem$ = new BehaviorSubject<DfSideNavItem | null>(null);\n    this._isAppOverlayMode = config.isAppOverlayMode;\n    this.subscription.add(\n      this._isCollapsed$.subscribe(() => {\n        this.updateOverLay();\n      })\n    );\n  }\n\n  ngOnDestroy() {\n    this.subscription.unsubscribe();\n  }\n\n  /**\n   * Use this to init the list of Elements from your sidenav\n   *\n   *\n   * Second option withRouter is to be set to false if you are not passing link string for the angular Router\n   * Here we are not deep copying the array --> the function will change it\n   */\n  initItems(items: DfSideNavItem[], withRouter = true) {\n    this._items = items;\n    this.addNavItemType(withRouter);\n    this.setActiveItem(this._items);\n    this.dispatchSideNavItems();\n  }\n\n  /**\n   * Use this to inactivate the list of Elements from your sidenav\n   * isActive properties of all items will be set to false recursively\n   *\n   */\n  inactiveItems(list: DfSideNavItem[]) {\n    list.forEach(item => {\n      item.isActive = false;\n      if (item.subMenus) {\n        this.inactiveItems(item.subMenus);\n      }\n    });\n    this.dispatchSideNavItems();\n  }\n\n  /**\n   * Use this to active the item pass as input\n   * This function inactivate all the other items of the service\n   * It will then dispatch the list of items of the sideNav to activeItem$\n   *\n   */\n  activeItem(item: DfSideNavItem) {\n    this.inactiveItems(this._items);\n    item.isActive = true;\n    this._activeItem$.next(item);\n    this.dispatchSideNavItems();\n  }\n\n  /**\n   * Getter to know when to put/remove the overlay.\n   * `True` in case of overlay needed\n   *\n   */\n  get isAppOverlay$(): Observable<boolean> {\n    return this._isAppOverlay$.asObservable();\n  }\n\n  /**\n   * Getter to know if the sidenav is in an overlay panel or not\n   * `True` in case of overlay panel\n   *\n   */\n  get isInMenuOverlay$(): Observable<boolean> {\n    return this._isInMenuOverlay$.asObservable();\n  }\n\n  /**\n   * Getter to know the current activeItem a user clicked on\n   *\n   */\n  get activeItem$(): Observable<DfSideNavItem | null> {\n    return this._activeItem$.asObservable();\n  }\n\n  /**\n   * Getter to know if the sideNav is present in the page\n   * SideNav may be collapsed here or not\n   *\n   */\n  get isPresent$(): Observable<boolean> {\n    return this._isPresent$.asObservable();\n  }\n\n  /**\n   * Future Options\n   */\n  get isMinimized$(): Observable<boolean> {\n    return this._isMinmized$.asObservable();\n  }\n\n  /**\n   * Getter to know if the SideNav is collapsed or not\n   * If `true` the SideNav is collapsed\n   *\n   */\n  get isCollapsed$(): Observable<boolean> {\n    return this._isCollapsed$.asObservable();\n  }\n\n  /**\n   * Getter of the SideNav Items after they have beens changed\n   *\n   */\n  get sideNavItems$(): Observable<DfSideNavItem[]> {\n    return this._sideNavItems$.asObservable();\n  }\n\n  /**\n   * Getter to know the mode Apply for the SideNav\n   * If `true` the SideNav can be in overlay (but not necessary is).\n   *\n   */\n  get isAppOverlayMode() {\n    return this._isAppOverlayMode;\n  }\n\n  // initItems must be used to push new items to the service\n  get items(): DfSideNavItem[] {\n    return this._items;\n  }\n\n  /**\n   * Use this to toggle a SideNav Item (either from expand to collapse or the other way around).\n   * isCollapsed attribute of the input item is changed.\n   * All items are push again to the stream of items.\n   * This is used internally by the SideNav in case of click and Enter on an Item with subMenus\n   */\n  toggle(itemInput: DfSideNavItem) {\n    itemInput.isCollapsed = !itemInput.isCollapsed;\n    this.dispatchSideNavItems();\n  }\n\n  /**\n   * \n   * @param itemInput \n   */\n  collapseItem(itemInput: DfSideNavItem) {\n    this.collapse(itemInput, this._items);\n    this.dispatchSideNavItems();\n  }\n\n  /**\n   * Use this to collapseAll items\n   */\n  collapseAllItems() {\n    this.collapseAll(this._items);\n    this.dispatchSideNavItems();\n  }\n\n  /**\n   * Use this to set/unset the SideNav in an Overlay Menu\n   * If input is `True` then the SideNav will be in an Overlay Menu\n   * (when not collapsed)\n   *\n   */\n  setInMenuSideNav(on: boolean) {\n    this._isInMenuOverlay$.next(on);\n  }\n\n  /**\n   * Use this to collapse the SideNav\n   *\n   */\n  hideSideNav() {\n    this._isCollapsed$.next(true);\n  }\n\n  /**\n   * Use this to make the SideNav visible (uncollapse)\n   *\n   */\n  showSideNav() {\n    this._isCollapsed$.next(false);\n  }\n\n  /**\n   * Use this to toggle the SideNav status collapse/visible\n   *\n   */\n  toggleSideNav() {\n    this._isCollapsed$.next(!this._isCollapsed$.value);\n  }\n\n  // internal usage from the SideNav. Call when component is destroy\n  removeSideBar() {\n    this._isCollapsed$.next(false);\n    this._isPresent$.next(false);\n  }\n\n  /**\n   * Use this to set the App Overlay Mode\n   * Input `True` if you want to set the AppOverlay\n   * An event is send to isAppOverlay$ depending on your status\n   * if Input = `True` and isCollapsed = `False` then isAppOverlay$\n   * will be `True`\n   *\n   */\n  setAppOverlayMode(on: boolean) {\n    this._isAppOverlayMode = on;\n    this.updateOverLay();\n  }\n\n  // Internal usage to the sidenav component\n  // Do not use\n  setSideNav() {\n    this._isPresent$.next(true);\n  }\n\n  /**\n   * \n   * @param itemInput \n   * @param itemsList \n   */\n  private collapse(itemInput: DfSideNavItem, itemsList: DfSideNavItem[]) : boolean {\n    for (const item of itemsList) {\n      if (item === itemInput && item.subMenus) {\n        item.isCollapsed = true;\n        return true; // propagate the collapse up\n      } else if (item === itemInput) {\n        return true;\n      } else if (item.subMenus) {\n        const needcol = this.collapse(itemInput, item.subMenus);\n        if (needcol) {\n          item.isCollapsed = true; // collapse it\n          return true; // propagate the collapse up\n        }\n      }\n    }\n    return false;\n  }\n\n  /**\n   * \n   * @param itemsList \n   */\n  private collapseAll(itemsList: DfSideNavItem[]) {\n    itemsList.forEach(item => {\n      if (item.subMenus) {\n        item.isCollapsed = true;\n        this.collapseAll(item.subMenus);\n      }\n    });\n  }\n\n  // Only one item at the time must be active\n  // Active flag in item is only valid for action button and link\n  // Router link does not use this active flag to work\n  // It is up to you to inactivateItems when needed when you mix actionButton and router link\n  // To avoid more than one active state visible\n  private setActiveItem(items : DfSideNavItem[], foundAnActive = false) : boolean {\n    let foundActive = foundAnActive;\n    items.forEach(item => {\n      if (item.isActive && foundAnActive) {\n          throw Error('DfSideNavService must be init with only one isActive item');\n      } else if (item.isActive) {\n          this._activeItem$.next(item);\n          foundActive = true;\n      }\n      if (item.subMenus) {\n        foundActive = this.setActiveItem(item.subMenus, foundActive);\n      }\n    });\n    return foundActive;\n  }\n\n  private addNavItemType(withRouter: boolean, items: DfSideNavItem[] = this._items) {\n    items.forEach(item => {\n      if (!item.type) {\n        if (item.subMenus) {\n          item.type = DfNavItemType.subMenus;\n        } else if (item.isExternal) {\n          item.type = DfNavItemType.externalLink;\n        } else if (withRouter) {\n          item.type = DfNavItemType.routerLink;\n        } else {\n          item.type = DfNavItemType.actionButton;\n        }\n      }\n      if (item.subMenus) {\n        this.addNavItemType(withRouter, item.subMenus);\n      }\n    });\n  }\n\n  private dispatchSideNavItems() {\n    this._sideNavItems$.next(this._items);\n  }\n\n  private updateOverLay() {\n    this._isAppOverlay$.next(this.isAppOverlayMode && this._isCollapsed$.value === false);\n  }\n}\n"]}