@energycap/components 0.42.4-esbuild.20250131-1219 → 0.42.4-esbuild.20250131-1256

package/esm2022/lib/controls/navigation/link-item.mjs

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

package/esm2022/lib/controls/navigation/nav-group.mjs

@@ -0,0 +1,39 @@
+import { Subject } from "rxjs";
+export class NavGroup {
+    /** Set selected to a NavItem and call selectItem if selected was previously defined */
+    set selected(item) {
+        this._selected = item;
+        if (item) {
+            this.selectItem(item);
+        }
+    }
+    ;
+    /** Get the value of the selected NavItem */
+    get selected() {
+        return this._selected;
+    }
+    /** Assign items to the NavGroup items */
+    constructor(items, defaultItem) {
+        /** The groups nav items */
+        this.items = [];
+        /** Broadcasts to subscribers when the value of the selected NavItem changed */
+        this.selectedChanges = new Subject();
+        if (items) {
+            this.items = items;
+            if (this.items.length && defaultItem) {
+                this._selected = defaultItem;
+            }
+        }
+    }
+    /** Call a selected NavItem's onClick method and broadcast the value of the selected NavItem to subscribers */
+    selectItem(item) {
+        if (item.url) {
+            return;
+        }
+        else if (item.onClick) {
+            item.onClick(item);
+        }
+        this.selectedChanges.next(item);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/controls/navigation/nav-item-active.directive.mjs

@@ -0,0 +1,92 @@
+import { Directive, Input, Output, EventEmitter } from '@angular/core';
+import { NavigationEnd } from '@angular/router';
+import { Subject } from 'rxjs';
+import { takeUntil, filter } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/router";
+export class NavItemActiveDirective {
+    /**
+     * Determines whether the directive will try to make an exact match on the url or not
+     * If false, the directive will add the active class if the first part of the url matches
+     * the active route.
+     * see: https://angular.io/api/router/Router#isactive
+     */
+    set exact(value) {
+        if (value === undefined) {
+            this._exact = true;
+        }
+        else {
+            this._exact = value;
+        }
+        this.update();
+    }
+    /**
+     * The url of the NavItem to check for activeness. Convert the item url into a
+     * UrlTree relative to the ActivatedRoute so router#isActive works even with relative urls.
+     * See Angular's [routerLink](https://github.com/angular/angular/blob/8282e15c2becbe42a49befa07d6407247e8243d8/packages/router/src/directives/router_link.ts#L249)
+     * and [routerLinkActive](https://github.com/angular/angular/blob/8282e15c2becbe42a49befa07d6407247e8243d8/packages/router/src/directives/router_link_active.ts#L139)
+     * for a similiar implementation.
+     */
+    set url(value) {
+        if (value !== null && value !== undefined) {
+            this._url = this.router.createUrlTree([value], { relativeTo: this.route, queryParams: this.queryParams });
+            this.update();
+        }
+    }
+    constructor(router, el, renderer, route) {
+        this.router = router;
+        this.el = el;
+        this.renderer = renderer;
+        this.route = route;
+        this._exact = true;
+        /** Emits when the url becomes active */
+        this.routerLinkActivated = new EventEmitter();
+        /** Subject that emits when component is destroyed to unsubscribe from any subscriptions */
+        this.destroyed = new Subject();
+    }
+    /** Check if url is active on NavigationEnd events */
+    ngOnInit() {
+        this.router.events.pipe(takeUntil(this.destroyed), filter(e => e instanceof NavigationEnd)).subscribe(() => {
+            this.update();
+        });
+    }
+    ngOnDestroy() {
+        this.destroyed.next();
+        this.destroyed.unsubscribe();
+    }
+    /** If url is active apply the defined class to the element, otherwise remove it */
+    update() {
+        if (this._url && this.classValue) {
+            if (this.router.isActive(this._url, { matrixParams: 'ignored', queryParams: this._exact ? 'exact' : 'subset', paths: this._exact ? 'exact' : 'subset', fragment: 'ignored' })) {
+                this.renderer.addClass(this.el.nativeElement, this.classValue);
+                this.routerLinkActivated.emit(new Event('routerLinkActivated'));
+            }
+            else {
+                this.renderer.removeClass(this.el.nativeElement, this.classValue);
+            }
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: NavItemActiveDirective, deps: [{ token: i1.Router }, { token: i0.ElementRef }, { token: i0.Renderer2 }, { token: i1.ActivatedRoute }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.3.12", type: NavItemActiveDirective, selector: "[ecNavItemActive]", inputs: { classValue: ["ecNavItemActive", "classValue"], exact: ["ecNavItemActiveExactMatch", "exact"], queryParams: ["ecNavItemActiveQueryParams", "queryParams"], url: ["ecNavItemActiveUrl", "url"] }, outputs: { routerLinkActivated: "routerLinkActivated" }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: NavItemActiveDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[ecNavItemActive]'
+                }]
+        }], ctorParameters: () => [{ type: i1.Router }, { type: i0.ElementRef }, { type: i0.Renderer2 }, { type: i1.ActivatedRoute }], propDecorators: { classValue: [{
+                type: Input,
+                args: ['ecNavItemActive']
+            }], exact: [{
+                type: Input,
+                args: ['ecNavItemActiveExactMatch']
+            }], queryParams: [{
+                type: Input,
+                args: ['ecNavItemActiveQueryParams']
+            }], url: [{
+                type: Input,
+                args: ['ecNavItemActiveUrl']
+            }], routerLinkActivated: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"nav-item-active.directive.js","sourceRoot":"","sources":["../../../../../../projects/components/src/lib/controls/navigation/nav-item-active.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import { Directive, Input, ElementRef, Renderer2, OnInit, OnDestroy, Output, EventEmitter } from '@angular/core';\r\nimport { Router, NavigationEnd, ActivatedRoute, UrlTree, Params } from '@angular/router';\r\nimport { Subject } from 'rxjs';\r\nimport { takeUntil, filter } from 'rxjs/operators';\r\n\r\n@Directive({\r\n  selector: '[ecNavItemActive]'\r\n})\r\nexport class NavItemActiveDirective implements OnInit, OnDestroy {\r\n\r\n  /** The CSS class to apply to the host element when the url is active */\r\n  @Input('ecNavItemActive') classValue?: string;\r\n\r\n  /**\r\n   * Determines whether the directive will try to make an exact match on the url or not\r\n   * If false, the directive will add the active class if the first part of the url matches\r\n   * the active route.\r\n   * see: https://angular.io/api/router/Router#isactive\r\n   */\r\n  @Input('ecNavItemActiveExactMatch')\r\n  set exact(value: boolean | undefined) {\r\n    if (value === undefined) {\r\n      this._exact = true;\r\n    } else {\r\n      this._exact = value;\r\n    }\r\n    this.update();\r\n  }\r\n  private _exact: boolean = true;\r\n\r\n  /** Router link query params */\r\n  @Input('ecNavItemActiveQueryParams') queryParams?: Params | null;\r\n\r\n  /**\r\n   * The url of the NavItem to check for activeness. Convert the item url into a\r\n   * UrlTree relative to the ActivatedRoute so router#isActive works even with relative urls.\r\n   * See Angular's [routerLink](https://github.com/angular/angular/blob/8282e15c2becbe42a49befa07d6407247e8243d8/packages/router/src/directives/router_link.ts#L249)\r\n   * and [routerLinkActive](https://github.com/angular/angular/blob/8282e15c2becbe42a49befa07d6407247e8243d8/packages/router/src/directives/router_link_active.ts#L139)\r\n   * for a similiar implementation.\r\n   */\r\n  @Input('ecNavItemActiveUrl')\r\n  set url(value: string | undefined) {\r\n    if (value !== null && value !== undefined) {\r\n      this._url = this.router.createUrlTree([value], {relativeTo: this.route, queryParams: this.queryParams});\r\n      this.update();\r\n    }\r\n  }\r\n  private _url?: UrlTree;\r\n\r\n  /** Emits when the url becomes active */\r\n  @Output() routerLinkActivated: EventEmitter<Event> = new EventEmitter();\r\n\r\n  /** Subject that emits when component is destroyed to unsubscribe from any subscriptions */\r\n  private destroyed: Subject<void> = new Subject();\r\n\r\n  constructor(private router: Router, private el: ElementRef, private renderer: Renderer2, private route: ActivatedRoute) {}\r\n\r\n  /** Check if url is active on NavigationEnd events */\r\n  public ngOnInit(): void {\r\n    this.router.events.pipe(\r\n      takeUntil(this.destroyed),\r\n      filter(e => e instanceof NavigationEnd)\r\n    ).subscribe(() => {\r\n      this.update();\r\n    })\r\n  }\r\n\r\n  public ngOnDestroy(): void {\r\n    this.destroyed.next();\r\n    this.destroyed.unsubscribe();\r\n  }\r\n\r\n  /** If url is active apply the defined class to the element, otherwise remove it */\r\n  private update(): void {\r\n    if (this._url && this.classValue) {\r\n      if (this.router.isActive(this._url, { matrixParams: 'ignored', queryParams: this._exact ? 'exact' : 'subset', paths: this._exact ? 'exact' : 'subset', fragment: 'ignored' })) {\r\n        this.renderer.addClass(this.el.nativeElement, this.classValue);\r\n        this.routerLinkActivated.emit(new Event('routerLinkActivated'));\r\n      } else {\r\n        this.renderer.removeClass(this.el.nativeElement, this.classValue);\r\n      }\r\n    }\r\n  }\r\n}\r\n"]}

package/esm2022/lib/controls/navigation/nav-item.mjs

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