@fundamental-ngx/btp 0.46.0-rc.100

package/tool-header/components/tool-header/tool-header.component.d.ts

@@ -0,0 +1,91 @@
+import { BooleanInput } from '@angular/cdk/coercion';
+import { EventEmitter, OnDestroy } from '@angular/core';
+import { SearchFieldComponent } from '@fundamental-ngx/btp/search-field';
+import { FdbViewMode } from '@fundamental-ngx/btp/shared';
+import { ToolHeaderActionsDirective } from '../../directives/tool-header-actions.directive';
+import { ToolHeaderLogoDirective } from '../../directives/tool-header-logo.directive';
+import { ToolHeaderUserDirective } from '../../directives/tool-header-user.directive';
+import { ToolHeaderComponentClass } from '../../tool-header-component.class';
+import * as i0 from "@angular/core";
+export declare class ToolHeaderComponent extends ToolHeaderComponentClass implements OnDestroy {
+    /**
+     * (required) the Product Name is the official name of the tool.
+     */
+    productName: string;
+    /**
+     * Second Title is an optional second text identifier of the tool.
+     **/
+    secondTitle?: string;
+    /** Mode */
+    set _mode(mode: FdbViewMode);
+    /** @hidden */
+    set _orientation(orientation: 'landscape' | 'portrait');
+    /**
+     * Whether to show the menu button
+     */
+    showMenuButton: BooleanInput;
+    /**
+     * Whether to show the voice input action button on
+     * the right side of the tool header, when the mode is mobile
+     * and the search input is expanded
+     */
+    showVoiceInputAction: BooleanInput;
+    /**
+     * Event emitted when the menu button is clicked
+     **/
+    menuClick: EventEmitter<void>;
+    /**
+     * Event emitted when user intends to expand the menu.
+     * Happens when user clicks `right arrow` key on the menu button
+     * if on ltr or `left arrow` key if on rtl.
+     **/
+    menuExpand: EventEmitter<void>;
+    /**
+     * Event emitted when user intends to collapse the menu.
+     * Happens when user clicks `left arrow` key on the menu button
+     * if on ltr or `right arrow` key if on rtl.
+     **/
+    menuCollapse: EventEmitter<void>;
+    /**
+     * Event emitted when the microphone button is clicked
+     **/
+    microphoneClick: EventEmitter<void>;
+    /**
+     * Event emitted when the default logo is clicked
+     */
+    logoClick: EventEmitter<void>;
+    /** @hidden */
+    _toolHeaderActionsDirective?: ToolHeaderActionsDirective;
+    /** @hidden */
+    _toolHeaderLogoDirective?: ToolHeaderLogoDirective;
+    /** @hidden */
+    set _searchField(searchField: SearchFieldComponent);
+    /** @hidden */
+    _toolHeaderUser?: ToolHeaderUserDirective;
+    /** @hidden */
+    _toolHeaderProductSwitch?: unknown;
+    /** @hidden */
+    private _searchFieldOutsideClickSubscription?;
+    /** @hidden */
+    private _ngZone;
+    /**
+     * The handler, responsible for closing the search field
+     * on outside click
+     * @hidden
+     **/
+    _onClick(event: MouseEvent): void;
+    /** @hidden */
+    ngOnDestroy(): void;
+    /**
+     * Expand the search field
+     **/
+    expandSearchField(): void;
+    /** @hidden */
+    protected _handleMenuLeftArrowKey(): void;
+    /** @hidden */
+    protected _handleMenuRightArrowKey(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ToolHeaderComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ToolHeaderComponent, "fdb-tool-header", never, { "productName": { "alias": "productName"; "required": true; }; "secondTitle": { "alias": "secondTitle"; "required": false; }; "_mode": { "alias": "mode"; "required": false; }; "_orientation": { "alias": "orientation"; "required": false; }; "showMenuButton": { "alias": "showMenuButton"; "required": false; }; "showVoiceInputAction": { "alias": "showVoiceInputAction"; "required": false; }; }, { "menuClick": "menuClick"; "menuExpand": "menuExpand"; "menuCollapse": "menuCollapse"; "microphoneClick": "microphoneClick"; "logoClick": "logoClick"; }, ["_toolHeaderActionsDirective", "_toolHeaderLogoDirective", "_searchField", "_toolHeaderUser", "_toolHeaderProductSwitch"], ["[fdbToolHeaderLogo]", "fdb-search-field", "[fdbToolHeaderUser]", "fdb-tool-header-product-switch, fd-product-switch"], true, never>;
+    static ngAcceptInputType_showMenuButton: any;
+    static ngAcceptInputType_showVoiceInputAction: any;
+}

package/tool-header/components/tool-header-product-switch.component.d.ts

@@ -0,0 +1,11 @@
+import { BasePopoverClass } from '@fundamental-ngx/core/popover';
+import { Placement } from '@fundamental-ngx/core/shared';
+import * as i0 from "@angular/core";
+export declare class ToolHeaderProductSwitchComponent extends BasePopoverClass {
+    /** Placement of a popover. */
+    placement: Placement;
+    /** Whether the product switch is disabled. */
+    disabled: boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ToolHeaderProductSwitchComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ToolHeaderProductSwitchComponent, "fdb-tool-header-product-switch", never, { "placement": { "alias": "placement"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, {}, never, ["*"], true, never>;
+}

package/tool-header/directives/tool-header-action.directive.d.ts

@@ -0,0 +1,35 @@
+import { EventEmitter, TemplateRef } from '@angular/core';
+import { FdbToolHeaderActionButton } from '../tool-header-action-button.type';
+import * as i0 from "@angular/core";
+export declare class ToolHeaderActionDirective implements FdbToolHeaderActionButton {
+    readonly templateRef: TemplateRef<any>;
+    /**
+     * Glyph which will be used for the action when in overflow mode.
+     */
+    glyph: string;
+    /**
+     * Label which will be used for the action when in overflow mode.
+     */
+    label: string;
+    /**
+     * Whether the action should have a separator next to it
+     */
+    hasSeparator: boolean;
+    /**
+     * Whether the action is always visible.
+     */
+    forceVisibility?: boolean;
+    /**
+     * Event emitted when the action is clicked when in overflow mode.
+     **/
+    clicked: EventEmitter<void>;
+    /** @hidden */
+    constructor(templateRef: TemplateRef<any>);
+    /**
+     * Function to be called when the action is clicked
+     * when in overflow mode.
+     **/
+    clickCallback: () => void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ToolHeaderActionDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ToolHeaderActionDirective, "[fdbToolHeaderAction]", never, { "glyph": { "alias": "glyph"; "required": true; }; "label": { "alias": "label"; "required": true; }; "hasSeparator": { "alias": "hasSeparator"; "required": false; }; "forceVisibility": { "alias": "forceVisibility"; "required": false; }; }, { "clicked": "clicked"; }, never, never, true, never>;
+}

package/tool-header/directives/tool-header-actions.directive.d.ts

@@ -0,0 +1,27 @@
+import { QueryList, Signal } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import { FdbToolHeaderActionButton } from '../tool-header-action-button.type';
+import { ToolHeaderActionDirective } from './tool-header-action.directive';
+import * as i0 from "@angular/core";
+export declare class ToolHeaderActionsDirective {
+    /**
+     * Actions to be displayed in the header.
+     */
+    set actions(actions: FdbToolHeaderActionButton[] | Array<FdbToolHeaderActionButton[]>);
+    /** @hidden */
+    set _actionsFromContent(actions: QueryList<ToolHeaderActionDirective>);
+    /** @hidden */
+    _actions: Signal<FdbToolHeaderActionButton[]>;
+    /** @hidden */
+    protected _contentActions$: BehaviorSubject<FdbToolHeaderActionButton[]>;
+    /** @hidden */
+    protected _inputActions$: BehaviorSubject<FdbToolHeaderActionButton[]>;
+    /** @hidden */
+    private _destroyRef;
+    /** @hidden */
+    private _contentActionsSubscription?;
+    /** @hidden */
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<ToolHeaderActionsDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ToolHeaderActionsDirective, "fdb-tool-header-actions", never, { "actions": { "alias": "actions"; "required": false; }; }, {}, ["_actionsFromContent"], never, true, never>;
+}

package/tool-header/directives/tool-header-auto-mode.directive.d.ts

@@ -0,0 +1,68 @@
+import { ElementRef, EventEmitter } from '@angular/core';
+import { FdbViewMode } from '@fundamental-ngx/btp/shared';
+import { HasElementRef } from '@fundamental-ngx/cdk/utils';
+import { ContentDensityDirective, ContentDensityMode } from '@fundamental-ngx/core/content-density';
+import { ToolHeaderComponent } from '../components/tool-header/tool-header.component';
+import * as i0 from "@angular/core";
+import * as i1 from "@fundamental-ngx/core/content-density";
+interface FdbToolHeaderModeConfig {
+    desktop: number;
+    tabletLandscape: [number, number];
+    tabletPortrait: [number, number];
+    phone: number;
+}
+export declare class ToolHeaderAutoModeDirective implements HasElementRef {
+    /**
+     * What sizes should be used to determine mode.
+     * Sizes mean the width of the tool header, not the whole screen.
+     **/
+    set config(config: Partial<FdbToolHeaderModeConfig>);
+    /**
+     * Current mode of the ToolHeaderComponent
+     */
+    modeChange: EventEmitter<FdbViewMode>;
+    /**
+     * Current orientation of the ToolHeaderComponent
+     */
+    orientationChange: EventEmitter<"landscape" | "portrait">;
+    /**
+     * Current content density of the ToolHeaderComponent
+     */
+    contentDensityChange: EventEmitter<ContentDensityMode>;
+    /**
+     * Reference to the element on which the directive is applied.
+     */
+    elementRef: ElementRef;
+    /**
+     * Current configuration of the directive.
+     */
+    protected _config: import("@angular/core").WritableSignal<FdbToolHeaderModeConfig>;
+    /** @hidden */
+    protected _contentDensity: ContentDensityDirective;
+    /**
+     * Signal of the Width of the element
+     */
+    protected _elementWidth: import("@angular/core").Signal<any>;
+    /**
+     * Reference to the ToolHeaderComponent
+     */
+    protected _toolHeaderComponent: ToolHeaderComponent;
+    /**
+     * Current mode of the ToolHeaderComponent
+     */
+    protected _currentMode: import("@angular/core").Signal<[FdbViewMode, "landscape" | "portrait"]>;
+    /**
+     * @hidden
+     */
+    constructor();
+    /**
+     * What mode should be used for the given width and configuration
+     * @param width
+     * @param config
+     * @private
+     */
+    private _getMode;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ToolHeaderAutoModeDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ToolHeaderAutoModeDirective, "fdb-tool-header[fdbToolHeaderAutoMode]", ["fdbToolHeaderAutoMode"], { "config": { "alias": "config"; "required": false; }; }, { "modeChange": "modeChange"; "orientationChange": "orientationChange"; "contentDensityChange": "contentDensityChange"; }, never, never, true, [{ directive: typeof i1.ContentDensityDirective; inputs: {}; outputs: {}; }]>;
+}
+export {};

package/tool-header/directives/tool-header-button.directive.d.ts

@@ -0,0 +1,22 @@
+import { ElementRef } from '@angular/core';
+import { HasElementRef } from '@fundamental-ngx/cdk';
+import * as i0 from "@angular/core";
+export declare class ToolHeaderButtonDirective implements HasElementRef {
+    /**
+     * Whether the button has a badge.
+     * @param hasBadge
+     */
+    set hasBadge(hasBadge: boolean);
+    /** @hidden */
+    elementRef: ElementRef<HTMLElement>;
+    /** @hidden */
+    private _badgeId;
+    /** @hidden */
+    private _badge?;
+    /** @hidden */
+    private renderer;
+    /** @hidden */
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<ToolHeaderButtonDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ToolHeaderButtonDirective, "[fd-button][fdbToolHeaderButton]", never, { "hasBadge": { "alias": "hasBadge"; "required": false; }; }, {}, never, never, true, never>;
+}

package/tool-header/directives/tool-header-element.directive.d.ts

@@ -0,0 +1,5 @@
+import * as i0 from "@angular/core";
+export declare class ToolHeaderElementDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ToolHeaderElementDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ToolHeaderElementDirective, "[fdbToolHeaderElement]", never, {}, {}, never, never, true, never>;
+}

package/tool-header/directives/tool-header-group.directive.d.ts

@@ -0,0 +1,12 @@
+import { BooleanInput } from '@angular/cdk/coercion';
+import * as i0 from "@angular/core";
+export declare class ToolHeaderGroupDirective {
+    /** @hidden */
+    center: BooleanInput;
+    /** @hidden */
+    actions: BooleanInput;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ToolHeaderGroupDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ToolHeaderGroupDirective, "[fdbToolHeaderGroup]", never, { "center": { "alias": "center"; "required": false; }; "actions": { "alias": "actions"; "required": false; }; }, {}, never, never, true, never>;
+    static ngAcceptInputType_center: any;
+    static ngAcceptInputType_actions: any;
+}

package/tool-header/directives/tool-header-logo.directive.d.ts

@@ -0,0 +1,5 @@
+import * as i0 from "@angular/core";
+export declare class ToolHeaderLogoDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ToolHeaderLogoDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ToolHeaderLogoDirective, "[fdbToolHeaderLogo]", never, {}, {}, never, never, true, never>;
+}

package/tool-header/directives/tool-header-user.directive.d.ts

@@ -0,0 +1,5 @@
+import * as i0 from "@angular/core";
+export declare class ToolHeaderUserDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ToolHeaderUserDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ToolHeaderUserDirective, "[fdbToolHeaderUser]", never, {}, {}, never, never, true, never>;
+}

package/tool-header/index.d.ts

@@ -0,0 +1,9 @@
+export * from './components/tool-header-product-switch.component';
+export * from './components/tool-header/tool-header.component';
+export * from './directives/tool-header-action.directive';
+export * from './directives/tool-header-actions.directive';
+export * from './directives/tool-header-auto-mode.directive';
+export * from './directives/tool-header-button.directive';
+export * from './directives/tool-header-logo.directive';
+export * from './directives/tool-header-user.directive';
+export * from './tool-header-action-button.type';

package/tool-header/tool-header-action-button.type.d.ts

@@ -0,0 +1,10 @@
+import { TemplateRef } from '@angular/core';
+export interface FdbToolHeaderActionButton {
+    templateRef?: TemplateRef<void>;
+    glyph: string;
+    label: string;
+    forceVisibility?: boolean;
+    clickCallback: () => void;
+    hasBadge?: boolean;
+    hasSeparator?: boolean;
+}

package/tool-header/tool-header-component.class.d.ts

@@ -0,0 +1,20 @@
+import { SearchFieldComponent } from '@fundamental-ngx/btp/search-field';
+import { FdbViewMode } from '@fundamental-ngx/btp/shared';
+import { FdbToolHeaderState } from './tool-header-state.type';
+export declare abstract class ToolHeaderComponentClass {
+    /** Mode signal */
+    mode: import("@angular/core").WritableSignal<FdbViewMode>;
+    /** @hidden */
+    orientation: import("@angular/core").WritableSignal<"landscape" | "portrait">;
+    /** @hidden */
+    protected fdbToolHeaderState: import("@angular/core").Signal<FdbToolHeaderState>;
+    /** Search field signal */
+    protected searchField: import("@angular/core").WritableSignal<SearchFieldComponent | null>;
+    /** @hidden */
+    protected searchFieldExpanded: import("@angular/core").WritableSignal<boolean>;
+    /**
+     * RTL signal
+     * @hidden
+     */
+    protected _rtl: import("@angular/core").Signal<boolean | undefined>;
+}

package/tool-header/tool-header-state.type.d.ts

@@ -0,0 +1,14 @@
+export interface FdbToolHeaderState {
+    backButtonVisible: boolean;
+    menuButtonVisible: boolean;
+    logoVisible: boolean;
+    productNameVisible: boolean;
+    secondTitleVisible: boolean;
+    searchFieldVisible: boolean;
+    searchFieldToggleActionVisible: boolean;
+    providedActionsVisible: boolean;
+    userAvatarVisible: boolean;
+    productSwitchVisible: boolean;
+    voiceInputVisible: boolean;
+    separatorsBetweenActionsVisible: boolean;
+}

package/tool-layout/README.md

@@ -0,0 +1,3 @@
+# @fundamental-ngx/btp/tool-layout
+
+Secondary entry point of `@fundamental-ngx/btp`. It can be used by importing from `@fundamental-ngx/btp/tool-layout`.

package/tool-layout/directives/tool-layout-container.directive.d.ts

@@ -0,0 +1,5 @@
+import * as i0 from "@angular/core";
+export declare class ToolLayoutContainerDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ToolLayoutContainerDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ToolLayoutContainerDirective, "[fdbToolLayoutContainer]", never, {}, {}, never, never, true, never>;
+}

package/tool-layout/directives/tool-layout-content-container.directive.d.ts

@@ -0,0 +1,29 @@
+import { ElementRef, OnChanges, OnInit } from '@angular/core';
+import { CssClassBuilder, HasElementRef } from '@fundamental-ngx/cdk/utils';
+import * as i0 from "@angular/core";
+export type ToolLayoutContentContainerBackground = '' | 'transparent' | 'list';
+export declare class ToolLayoutContentContainerDirective implements OnChanges, OnInit, CssClassBuilder, HasElementRef {
+    /** user's custom classes */
+    class: string;
+    /**
+     * the background of the Content Container
+     * Available options: '' | 'transparent' | 'list'
+     * Default background has the color var(--sapBackgroundColor)
+     * List background will apply var(--sapGroup_ContentBackground) background to the content area
+     */
+    background: ToolLayoutContentContainerBackground;
+    /** @hidden */
+    readonly elementRef: ElementRef<HTMLElement>;
+    /** @hidden
+     * CssClassBuilder interface implementation
+     * function must return single string
+     * function is responsible for order which css classes are applied
+     */
+    buildComponentCssClass(): string[];
+    /** @hidden */
+    ngOnInit(): void;
+    /** @hidden */
+    ngOnChanges(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ToolLayoutContentContainerDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ToolLayoutContentContainerDirective, "[fdbToolLayoutContentContainer]", never, { "class": { "alias": "class"; "required": false; }; "background": { "alias": "background"; "required": false; }; }, {}, never, never, true, never>;
+}

package/tool-layout/directives/tool-layout-header-container.directive.d.ts

@@ -0,0 +1,5 @@
+import * as i0 from "@angular/core";
+export declare class ToolLayoutHeaderContainerDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ToolLayoutHeaderContainerDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ToolLayoutHeaderContainerDirective, "[fdbToolLayoutHeaderContainer]", never, {}, {}, never, never, true, never>;
+}

package/tool-layout/directives/tool-layout-navigation-container.directive.d.ts

@@ -0,0 +1,13 @@
+import * as i0 from "@angular/core";
+export declare class ToolLayoutNavigationContainerDirective {
+    /**
+     * whether the navigation is a popup
+     */
+    popup: boolean;
+    /**
+     * whether the navigation is horizontal
+     */
+    horizontal: boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ToolLayoutNavigationContainerDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ToolLayoutNavigationContainerDirective, "[fdbToolLayoutNavigationContainer]", never, { "popup": { "alias": "popup"; "required": false; }; "horizontal": { "alias": "horizontal"; "required": false; }; }, {}, never, never, true, never>;
+}

package/tool-layout/index.d.ts

@@ -0,0 +1,6 @@
+export * from './directives/tool-layout-container.directive';
+export * from './directives/tool-layout-content-container.directive';
+export * from './directives/tool-layout-header-container.directive';
+export * from './directives/tool-layout-navigation-container.directive';
+export * from './tool-layout.component';
+export * from './tool-layout.module';

package/tool-layout/tool-layout.component.d.ts

@@ -0,0 +1,27 @@
+import { ElementRef, OnChanges, OnInit } from '@angular/core';
+import { FdbViewMode } from '@fundamental-ngx/btp/shared';
+import { CssClassBuilder, HasElementRef, Nullable } from '@fundamental-ngx/cdk/utils';
+import * as i0 from "@angular/core";
+export declare class ToolLayoutComponent implements OnChanges, OnInit, CssClassBuilder, HasElementRef {
+    /** user's custom classes */
+    class: string;
+    /** Whether the Tool Layout is in Desktop, Tablet or Mobile/Phone mode
+     * Types available: '' | 'tablet' | 'phone'
+     * The default (not specified) mode is desktop.
+     */
+    mode: Nullable<FdbViewMode>;
+    /** @hidden */
+    readonly elementRef: ElementRef<HTMLElement>;
+    /** @hidden
+     * CssClassBuilder interface implementation
+     * function must return single string
+     * function is responsible for order which css classes are applied
+     */
+    buildComponentCssClass(): string[];
+    /** @hidden */
+    ngOnInit(): void;
+    /** @hidden */
+    ngOnChanges(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ToolLayoutComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ToolLayoutComponent, "[fdbToolLayout]", never, { "class": { "alias": "class"; "required": false; }; "mode": { "alias": "mode"; "required": false; }; }, {}, never, ["*"], true, never>;
+}

package/tool-layout/tool-layout.module.d.ts

@@ -0,0 +1,11 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./tool-layout.component";
+import * as i2 from "./directives/tool-layout-container.directive";
+import * as i3 from "./directives/tool-layout-content-container.directive";
+import * as i4 from "./directives/tool-layout-header-container.directive";
+import * as i5 from "./directives/tool-layout-navigation-container.directive";
+export declare class ToolLayoutModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ToolLayoutModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ToolLayoutModule, never, [typeof i1.ToolLayoutComponent, typeof i2.ToolLayoutContainerDirective, typeof i3.ToolLayoutContentContainerDirective, typeof i4.ToolLayoutHeaderContainerDirective, typeof i5.ToolLayoutNavigationContainerDirective], [typeof i1.ToolLayoutComponent, typeof i2.ToolLayoutContainerDirective, typeof i3.ToolLayoutContentContainerDirective, typeof i4.ToolLayoutHeaderContainerDirective, typeof i5.ToolLayoutNavigationContainerDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ToolLayoutModule>;
+}