@fundamental-ngx/btp 0.46.0-rc.100

package/esm2022/navigation/navigation-link.component.mjs

@@ -0,0 +1,188 @@
+import { __decorate, __metadata } from "tslib";
+/* eslint-disable @angular-eslint/no-host-metadata-property */
+import { AsyncPipe, NgIf, NgTemplateOutlet } from '@angular/common';
+import { ChangeDetectionStrategy, Component, ElementRef, HostBinding, HostListener, Input, TemplateRef, ViewChild, ViewEncapsulation, inject } from '@angular/core';
+import { toSignal } from '@angular/core/rxjs-interop';
+import { RouterLink, RouterLinkActive } from '@angular/router';
+import { applyCssClass } from '@fundamental-ngx/cdk/utils';
+import { IconComponent } from '@fundamental-ngx/core/icon';
+import { FdbNavigationComponent } from './navigation-component.token';
+import { FdbNavigationListItemComponent } from './navigation-list-item-component.token';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/router";
+export class NavigationLinkComponent {
+    /** @hidden */
+    constructor() {
+        /** Whether the link is for the external resource. */
+        this.external = false;
+        /** @hidden */
+        this._tabindex = 0;
+        /** @hidden */
+        this.elementRef = inject(ElementRef);
+        /** @hidden */
+        this._routerLink = inject(RouterLink, {
+            optional: true,
+            self: true
+        });
+        /** @hidden */
+        this._routerLinkActive = inject(RouterLinkActive, { optional: true });
+        /**
+         * If user applies RouterLink, we need to check if the link is active
+         * @hidden
+         **/
+        this.isActive = toSignal(inject(RouterLinkActive).isActiveChange);
+        /** @hidden */
+        this.navigationListItemComponent = inject(FdbNavigationListItemComponent);
+        /** @hidden */
+        this._navigationComponent = inject(FdbNavigationComponent);
+        this.navigationListItemComponent.linkComponent = this;
+        this.navigationListItemComponent.routerLink.set(this._routerLink);
+        this.navigationListItemComponent.routerLinkActive.set(this._routerLinkActive);
+    }
+    /** @hidden */
+    buildComponentCssClass() {
+        return [this.class || '', 'fd-navigation__link'];
+    }
+    /** @hidden */
+    _onClick() {
+        if (this.navigationListItemComponent.childNavigationListComponent()) {
+            this.navigationListItemComponent.toggle();
+        }
+    }
+    /** @hidden */
+    _focusHandler() {
+        this._navigationComponent.setActiveItem(this.navigationListItemComponent);
+    }
+    /** @hidden */
+    ngOnChanges() {
+        this.buildComponentCssClass();
+    }
+    /** @hidden */
+    ngOnInit() {
+        this.buildComponentCssClass();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.7", ngImport: i0, type: NavigationLinkComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.7", type: NavigationLinkComponent, isStandalone: true, selector: "a[fdb-navigation-link]", inputs: { class: "class", glyph: "glyph", label: "label", external: "external" }, host: { attributes: { "role": "link" }, listeners: { "click": "_onClick()", "focus": "_focusHandler()" }, properties: { "attr.tabindex": "this._tabindex" } }, viewQueries: [{ propertyName: "textRenderer", first: true, predicate: ["textRenderer"], descendants: true }], usesOnChanges: true, hostDirectives: [{ directive: i1.RouterLinkActive }], ngImport: i0, template: `
+        <ng-container *ngIf="glyph">
+            <fd-icon
+                [glyph]="glyph"
+                class="fd-navigation__icon"
+                [attr.role]="'presentation'"
+                [ariaHidden]="true"
+            ></fd-icon>
+        </ng-container>
+        <ng-template #textRenderer>
+            <span class="fd-navigation__text">{{ label }}</span>
+            <span
+                class="fd-navigation__external-link-indicator"
+                role="presentation"
+                aria-hidden="true"
+                aria-label="external link indicator"
+                *ngIf="external"
+            ></span>
+        </ng-template>
+        <ng-container *ngTemplateOutlet="textRenderer" />
+        <span
+            class="fd-navigation__selection-indicator"
+            role="presentation"
+            aria-hidden="true"
+            aria-label="selection indicator"
+        >
+        </span>
+        <span
+            *ngIf="
+                navigationListItemComponent?.childNavigationListComponent() &&
+                navigationListItemComponent?.normalizedLevel() !== 3 &&
+                !_routerLink
+            "
+            class="fd-navigation__has-children-indicator"
+            role="presentation"
+            aria-hidden="true"
+            aria-label="has children indicator, expanded"
+        >
+        </span>
+    `, isInline: true, dependencies: [{ kind: "directive", type: NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "component", type: IconComponent, selector: "fd-icon", inputs: ["glyph", "font", "class", "ariaLabel", "ariaHidden"] }, { kind: "directive", type: NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None }); }
+}
+__decorate([
+    applyCssClass,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Array)
+], NavigationLinkComponent.prototype, "buildComponentCssClass", null);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.7", ngImport: i0, type: NavigationLinkComponent, decorators: [{
+            type: Component,
+            args: [{
+                    // eslint-disable-next-line @angular-eslint/component-selector
+                    selector: 'a[fdb-navigation-link]',
+                    template: `
+        <ng-container *ngIf="glyph">
+            <fd-icon
+                [glyph]="glyph"
+                class="fd-navigation__icon"
+                [attr.role]="'presentation'"
+                [ariaHidden]="true"
+            ></fd-icon>
+        </ng-container>
+        <ng-template #textRenderer>
+            <span class="fd-navigation__text">{{ label }}</span>
+            <span
+                class="fd-navigation__external-link-indicator"
+                role="presentation"
+                aria-hidden="true"
+                aria-label="external link indicator"
+                *ngIf="external"
+            ></span>
+        </ng-template>
+        <ng-container *ngTemplateOutlet="textRenderer" />
+        <span
+            class="fd-navigation__selection-indicator"
+            role="presentation"
+            aria-hidden="true"
+            aria-label="selection indicator"
+        >
+        </span>
+        <span
+            *ngIf="
+                navigationListItemComponent?.childNavigationListComponent() &&
+                navigationListItemComponent?.normalizedLevel() !== 3 &&
+                !_routerLink
+            "
+            class="fd-navigation__has-children-indicator"
+            role="presentation"
+            aria-hidden="true"
+            aria-label="has children indicator, expanded"
+        >
+        </span>
+    `,
+                    imports: [NgIf, IconComponent, AsyncPipe, NgTemplateOutlet],
+                    hostDirectives: [RouterLinkActive],
+                    standalone: true,
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    encapsulation: ViewEncapsulation.None,
+                    host: {
+                        role: 'link'
+                    }
+                }]
+        }], ctorParameters: function () { return []; }, propDecorators: { class: [{
+                type: Input
+            }], glyph: [{
+                type: Input
+            }], label: [{
+                type: Input,
+                args: [{ required: true }]
+            }], external: [{
+                type: Input
+            }], textRenderer: [{
+                type: ViewChild,
+                args: ['textRenderer']
+            }], _tabindex: [{
+                type: HostBinding,
+                args: ['attr.tabindex']
+            }], buildComponentCssClass: [], _onClick: [{
+                type: HostListener,
+                args: ['click']
+            }], _focusHandler: [{
+                type: HostListener,
+                args: ['focus']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"navigation-link.component.js","sourceRoot":"","sources":["../../../../../libs/btp/navigation/navigation-link.component.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable @angular-eslint/no-host-metadata-property */\nimport { AsyncPipe, NgIf, NgTemplateOutlet } from '@angular/common';\nimport {\n    ChangeDetectionStrategy,\n    Component,\n    ElementRef,\n    HostBinding,\n    HostListener,\n    Input,\n    OnChanges,\n    OnInit,\n    TemplateRef,\n    ViewChild,\n    ViewEncapsulation,\n    inject\n} from '@angular/core';\nimport { toSignal } from '@angular/core/rxjs-interop';\nimport { RouterLink, RouterLinkActive } from '@angular/router';\nimport { CssClassBuilder, HasElementRef, applyCssClass } from '@fundamental-ngx/cdk/utils';\nimport { IconComponent } from '@fundamental-ngx/core/icon';\nimport { FdbNavigationComponent } from './navigation-component.token';\nimport { FdbNavigationListItemComponent } from './navigation-list-item-component.token';\n\n@Component({\n    // eslint-disable-next-line @angular-eslint/component-selector\n    selector: 'a[fdb-navigation-link]',\n    template: `\n        <ng-container *ngIf=\"glyph\">\n            <fd-icon\n                [glyph]=\"glyph\"\n                class=\"fd-navigation__icon\"\n                [attr.role]=\"'presentation'\"\n                [ariaHidden]=\"true\"\n            ></fd-icon>\n        </ng-container>\n        <ng-template #textRenderer>\n            <span class=\"fd-navigation__text\">{{ label }}</span>\n            <span\n                class=\"fd-navigation__external-link-indicator\"\n                role=\"presentation\"\n                aria-hidden=\"true\"\n                aria-label=\"external link indicator\"\n                *ngIf=\"external\"\n            ></span>\n        </ng-template>\n        <ng-container *ngTemplateOutlet=\"textRenderer\" />\n        <span\n            class=\"fd-navigation__selection-indicator\"\n            role=\"presentation\"\n            aria-hidden=\"true\"\n            aria-label=\"selection indicator\"\n        >\n        </span>\n        <span\n            *ngIf=\"\n                navigationListItemComponent?.childNavigationListComponent() &&\n                navigationListItemComponent?.normalizedLevel() !== 3 &&\n                !_routerLink\n            \"\n            class=\"fd-navigation__has-children-indicator\"\n            role=\"presentation\"\n            aria-hidden=\"true\"\n            aria-label=\"has children indicator, expanded\"\n        >\n        </span>\n    `,\n    imports: [NgIf, IconComponent, AsyncPipe, NgTemplateOutlet],\n    hostDirectives: [RouterLinkActive],\n    standalone: true,\n    changeDetection: ChangeDetectionStrategy.OnPush,\n    encapsulation: ViewEncapsulation.None,\n    host: {\n        role: 'link'\n    }\n})\nexport class NavigationLinkComponent implements OnInit, OnChanges, CssClassBuilder, HasElementRef {\n    /** @hidden */\n    @Input()\n    class: string;\n\n    /** @hidden */\n    @Input()\n    glyph: string;\n\n    /** Label to be displayed as a link text. */\n    @Input({ required: true })\n    label: string;\n\n    /** Whether the link is for the external resource. */\n    @Input()\n    external = false;\n\n    /** @hidden */\n    @ViewChild('textRenderer')\n    textRenderer: TemplateRef<any>;\n\n    /** @hidden */\n    @HostBinding('attr.tabindex')\n    _tabindex = 0;\n\n    /** @hidden */\n    readonly elementRef: ElementRef<HTMLElement> = inject(ElementRef);\n\n    /** @hidden */\n    readonly _routerLink = inject(RouterLink, {\n        optional: true,\n        self: true\n    });\n\n    /** @hidden */\n    readonly _routerLinkActive = inject(RouterLinkActive, { optional: true });\n\n    /**\n     * If user applies RouterLink, we need to check if the link is active\n     * @hidden\n     **/\n    protected isActive = toSignal(inject(RouterLinkActive).isActiveChange);\n\n    /** @hidden */\n    protected navigationListItemComponent = inject(FdbNavigationListItemComponent);\n\n    /** @hidden */\n    private readonly _navigationComponent = inject(FdbNavigationComponent);\n\n    /** @hidden */\n    constructor() {\n        this.navigationListItemComponent.linkComponent = this;\n        this.navigationListItemComponent.routerLink.set(this._routerLink);\n        this.navigationListItemComponent.routerLinkActive.set(this._routerLinkActive);\n    }\n\n    /** @hidden */\n    @applyCssClass\n    buildComponentCssClass(): string[] {\n        return [this.class || '', 'fd-navigation__link'];\n    }\n\n    /** @hidden */\n    @HostListener('click')\n    private _onClick(): void {\n        if (this.navigationListItemComponent.childNavigationListComponent()) {\n            this.navigationListItemComponent.toggle();\n        }\n    }\n\n    /** @hidden */\n    @HostListener('focus')\n    private _focusHandler(): void {\n        this._navigationComponent.setActiveItem(this.navigationListItemComponent);\n    }\n\n    /** @hidden */\n    ngOnChanges(): void {\n        this.buildComponentCssClass();\n    }\n\n    /** @hidden */\n    ngOnInit(): void {\n        this.buildComponentCssClass();\n    }\n}\n"]}