@hermes-ui/angular 0.1.4

package/types/hermes-ui-angular-popover-dropdown.d.ts

@@ -0,0 +1,124 @@
+import * as i0 from '@angular/core';
+import { OnDestroy, Renderer2, ChangeDetectorRef, AfterContentInit, QueryList, ElementRef, Type } from '@angular/core';
+import * as i1 from '@hermes-ui/angular/popover/common';
+import { HermesPopoverService, HermesPopoverPoint, HermesPopoverContent, HermesPopoverPosition } from '@hermes-ui/angular/popover/common';
+import { FocusableItem, FocusService } from '@hermes-ui/angular/utils';
+import { Observable } from 'rxjs';
+import * as i5 from '@angular/common';
+import * as i6 from '@hermes-ui/angular/icon';
+
+declare class DropdownFocusHandler implements OnDestroy, FocusableItem {
+    private renderer;
+    private parent;
+    private popoverService;
+    private focusService;
+    private platformId;
+    id: string;
+    right?: Observable<FocusableItem>;
+    down?: Observable<FocusableItem>;
+    up?: Observable<FocusableItem>;
+    private _trigger;
+    private _container;
+    private children;
+    private _unlistenFuncs;
+    constructor(renderer: Renderer2, parent: DropdownFocusHandler, popoverService: HermesPopoverService, focusService: FocusService, platformId: any);
+    get trigger(): HTMLElement;
+    set trigger(el: HTMLElement);
+    get container(): HTMLElement;
+    set container(el: HTMLElement);
+    ngOnDestroy(): void;
+    /**
+     * If the dropdown was opened by clicking on the trigger, we automatically move to the first item
+     */
+    moveToFirstItemWhenOpen(): void;
+    focus(): void;
+    blur(): void;
+    activate(): void;
+    resetChildren(): void;
+    addChildren(children: FocusableItem[]): void;
+    private openAndGetChildren;
+    private closeAndGetThis;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DropdownFocusHandler, [null, { optional: true; skipSelf: true; }, null, null, null]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DropdownFocusHandler>;
+}
+
+declare class RootDropdownService {
+    private _changes;
+    get changes(): Observable<boolean>;
+    closeMenus(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RootDropdownService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<RootDropdownService>;
+}
+
+declare class HermesDropdown implements OnDestroy {
+    parent: HermesDropdown;
+    popoverService: HermesPopoverService;
+    focusHandler: DropdownFocusHandler;
+    isMenuClosable: boolean;
+    private subscriptions;
+    constructor(parent: HermesDropdown, popoverService: HermesPopoverService, focusHandler: DropdownFocusHandler, cdr: ChangeDetectorRef, dropdownService: RootDropdownService);
+    openAtPoint(point: HermesPopoverPoint, targetElement?: HTMLElement): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HermesDropdown, [{ optional: true; skipSelf: true; }, null, null, null, null]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HermesDropdown, "hermes-dropdown", never, { "isMenuClosable": { "alias": "hermesCloseMenuOnItemClick"; "required": false; }; }, {}, never, ["*"], false, [{ directive: typeof i1.HermesPopoverHostDirective; inputs: {}; outputs: {}; }]>;
+}
+
+declare class HermesDropdownMenu implements AfterContentInit, OnDestroy {
+    private focusHandler;
+    private elementRef;
+    private popoverService;
+    private popoverContent;
+    items: QueryList<FocusableItem>;
+    constructor(parentHost: ElementRef<HTMLElement>, nested: HermesDropdownMenu, focusHandler: DropdownFocusHandler, elementRef: ElementRef, popoverService: HermesPopoverService, popoverContent: HermesPopoverContent);
+    get isOffScreen(): boolean;
+    set position(position: string | HermesPopoverPosition);
+    ngAfterContentInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HermesDropdownMenu, [{ optional: true; }, { optional: true; skipSelf: true; }, null, null, null, null]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HermesDropdownMenu, "hermes-dropdown-menu", never, { "position": { "alias": "hermesPosition"; "required": false; }; }, {}, ["items"], ["*"], false, [{ directive: typeof i1.HermesPopoverContent; inputs: {}; outputs: {}; }]>;
+}
+
+declare class HermesDropdownTrigger {
+    private popoverService;
+    isRootLevelToggle: boolean;
+    constructor(dropdown: HermesDropdown, popoverService: HermesPopoverService, el: ElementRef<HTMLElement>, focusHandler: DropdownFocusHandler);
+    get active(): boolean;
+    onDropdownTriggerClick(event: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HermesDropdownTrigger, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HermesDropdownTrigger, "[hermesDropdownTrigger],[hermesDropdownToggle]", never, {}, {}, never, never, false, never>;
+}
+
+declare class HermesDropdownItem {
+    private dropdown;
+    private _dropdownService;
+    private focusableItem;
+    private el;
+    private renderer;
+    constructor(dropdown: HermesDropdown, _dropdownService: RootDropdownService, focusableItem: FocusableItem, el: ElementRef, renderer: Renderer2);
+    get disabled(): boolean | string;
+    set disabled(value: boolean | string);
+    /**
+     * Let you overwrite the focusable auto increment id.
+     */
+    get dropdownItemId(): string;
+    set dropdownItemId(value: string);
+    private onDropdownItemClick;
+    private onSpaceKeydown;
+    private onEnterKeydown;
+    private stopImmediatePropagationIfDisabled;
+    private findRootDropdown;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HermesDropdownItem, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HermesDropdownItem, "[hermesDropdownItem]", never, { "disabled": { "alias": "hermesDisabled"; "required": false; }; "dropdownItemId": { "alias": "id"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare const HERMES_MENU_POSITIONS: string[];
+
+declare const HERMES_DROPDOWN_DIRECTIVES: Type<any>[];
+declare class HermesDropdownModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<HermesDropdownModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<HermesDropdownModule, [typeof HermesDropdown, typeof HermesDropdownMenu, typeof HermesDropdownTrigger, typeof HermesDropdownItem], [typeof i5.CommonModule, typeof i6.HermesIcon, typeof i1.HermesIfOpen], [typeof HermesDropdown, typeof HermesDropdownMenu, typeof HermesDropdownTrigger, typeof HermesDropdownItem, typeof i1.HermesIfOpen, typeof i6.HermesIcon]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<HermesDropdownModule>;
+}
+
+export { HERMES_DROPDOWN_DIRECTIVES, HERMES_MENU_POSITIONS, HermesDropdown, HermesDropdownItem, HermesDropdownMenu, HermesDropdownModule, HermesDropdownTrigger };
+//# sourceMappingURL=hermes-ui-angular-popover-dropdown.d.ts.map

package/types/hermes-ui-angular-popover-dropdown.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hermes-ui-angular-popover-dropdown.d.ts","sources":["../../../popover/dropdown/providers/dropdown-focus-handler.service.ts","../../../popover/dropdown/providers/dropdown.service.ts","../../../popover/dropdown/dropdown.ts","../../../popover/dropdown/dropdown-menu.ts","../../../popover/dropdown/dropdown-trigger.ts","../../../popover/dropdown/dropdown-item.ts","../../../popover/dropdown/menu-positions.ts","../../../popover/dropdown/dropdown.module.ts"],"mappings":";;;;;;;;;AAqBA,cACa,oBAAqB,YAAW,SAAS,EAAE,aAAa;AAajE;AAGA;AACA;AACA;AACqB;AAlBvB;AAEA,YAAQ,UAAU,CAAC,aAAa;AAChC,WAAO,UAAU,CAAC,aAAa;AAC/B,SAAK,UAAU,CAAC,aAAa;;;;;AAQnB,0BAAU,SAAS,UAGX,oBAAoB,kBACZ,oBAAoB,gBACtB,YAAY;mBAUpB,WAAW;AAA3B,oBAAgB,WAAW;qBAqBT,WAAW;AAA7B,sBAAkB,WAAW;;AA+B7B;;AAEG;;;;;;AAgDH,0BAAsB,aAAa;AAQnC;AAIA;yCA9IW,oBAAoB;6CAApB,oBAAoB;AAiJhC;;AC7JD,cACa,mBAAmB;;AAG9B,mBAAe,UAAU;AAIzB;yCAPW,mBAAmB;6CAAnB,mBAAmB;AAU/B;;ACPD,cAWa,cAAe,YAAW,SAAS;AAQrC,YAAQ,cAAc;AACtB,oBAAgB,oBAAoB;AACpC,kBAAc,oBAAoB;AATN;;AAO5B,wBAAQ,cAAc,kBACN,oBAAoB,gBACtB,oBAAoB,OACpC,iBAAiB,mBACL,mBAAmB;uBAMnB,kBAAkB,kBAAkB,WAAW;;yCAlBvD,cAAc;2CAAd,cAAc,gKAAA,EAAA,CAAA,0BAAA;AAyB1B;;AClBD,cAUa,kBAAmB,YAAW,gBAAgB,EAAE,SAAS;AAUlE;AACA;AACA;AACA;AAZ8B,WAAO,SAAS,CAAC,aAAa;4BAKhD,UAAU,CAAC,WAAW,WAG1B,kBAAkB,gBACJ,oBAAoB,cACtB,UAAU,kBACN,oBAAoB,kBACpB,oBAAoB;AAkB9C;AAKA,oCACgC,qBAAqB;;;yCArC1C,kBAAkB;2CAAlB,kBAAkB,uJAAA,EAAA,CAAA,oBAAA;AA8D9B;;AC3FD,cAaa,qBAAqB;AAK9B;AAJF;AAGE,0BAAU,cAAc,kBACA,oBAAoB,MACxC,UAAU,CAAC,WAAW,iBACZ,oBAAoB;;AAepC;yCAtBW,qBAAqB;2CAArB,qBAAqB;AAyBjC;;ACtCD,cAYa,kBAAkB;AAE3B;AACA;AACA;AACA;AACA;AAJQ,0BAAU,cAAc,oBACN,mBAAmB,iBACtB,aAAa,MACxB,UAAU,YACJ,SAAS;AAG7B;AAIA;AAKA;;AAEG;;AAKH;AAKA;AAkBA;AAKA;AAIA;AAOA;yCAhEW,kBAAkB;2CAAlB,kBAAkB;AAyE9B;;AC3FD,cAAa,qBAAqB;;ACUlC,cAAa,0BAA0B,EAAE,IAAI;AAE7C,cAKa,oBAAoB;yCAApB,oBAAoB;0CAApB,oBAAoB,UAAAA,cAAA,SAAAC,kBAAA,SAAAC,qBAAA,SAAAC,kBAAA,WAAA,EAAA,CAAA,YAAA,SAAA,EAAA,CAAA,UAAA,SAAAC,EAAA,CAAA,YAAA,WAAAJ,cAAA,SAAAC,kBAAA,SAAAC,qBAAA,SAAAC,kBAAA,SAAAC,EAAA,CAAA,YAAA,SAAA,EAAA,CAAA,UAAA;0CAApB,oBAAoB;AAAG;;","names":["i1.HermesDropdown","i2.HermesDropdownMenu","i3.HermesDropdownTrigger","i4.HermesDropdownItem","i7"]}

package/types/hermes-ui-angular-popover-signpost.d.ts

@@ -0,0 +1,158 @@
+import * as i8 from '@hermes-ui/angular/popover/common';
+import { HermesPopoverService, HermesPopoverPoint, HermesPopoverContent, HermesPopoverPosition } from '@hermes-ui/angular/popover/common';
+import * as i7 from '@hermes-ui/angular/utils';
+import { HermesCommonStringsService } from '@hermes-ui/angular/utils';
+import * as i0 from '@angular/core';
+import { OnDestroy, ElementRef, AfterViewInit, Type } from '@angular/core';
+import { Observable } from 'rxjs';
+import * as i5 from '@angular/common';
+import * as i6 from '@hermes-ui/angular/icon';
+
+declare class SignpostFocusManager {
+    private _triggerEl;
+    set triggerEl(value: HTMLElement);
+    focusTrigger(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SignpostFocusManager, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SignpostFocusManager>;
+}
+
+declare class SignpostIdService {
+    private _id;
+    get id(): Observable<string>;
+    setId(id: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SignpostIdService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SignpostIdService>;
+}
+
+declare class HermesSignpostTrigger implements OnDestroy {
+    private popoverService;
+    private el;
+    private signpostIdService;
+    private signpostFocusManager;
+    private platformId;
+    ariaExpanded: boolean;
+    ariaControl: string;
+    isOpen: boolean;
+    private document;
+    private subscriptions;
+    constructor(popoverService: HermesPopoverService, el: ElementRef<HTMLElement>, signpostIdService: SignpostIdService, signpostFocusManager: SignpostFocusManager, document: any, platformId: any);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    /**********
+     *
+     * @description
+     * click handler for the HermesSignpost trigger button used to hide/show HermesSignpostContent.
+     */
+    onSignpostTriggerClick(event: Event): void;
+    private focusOnClose;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HermesSignpostTrigger, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HermesSignpostTrigger, "[hermesSignpostTrigger]", never, {}, {}, never, never, false, never>;
+}
+
+declare class HermesSignpost {
+    commonStrings: HermesCommonStringsService;
+    private popoverService;
+    /**********
+     * @property useCustomTrigger
+     *
+     * @description
+     * Flag used to determine if we need to use the default trigger or a user supplied trigger element.
+     *
+     */
+    useCustomTrigger: boolean;
+    signpostTriggerAriaLabel: string;
+    /**
+     * Hides the default trigger button. Use when the signpost is opened
+     * programmatically via `openAtPoint()` and no trigger icon is needed.
+     */
+    hideTrigger: boolean;
+    constructor(commonStrings: HermesCommonStringsService, popoverService: HermesPopoverService);
+    /**********
+     * @property signPostTrigger
+     *
+     * @description
+     * Uses ContentChild to check for a user supplied element with the HermesSignpostTrigger on it.
+     *
+     */
+    set customTrigger(trigger: HermesSignpostTrigger);
+    get showDefaultTrigger(): boolean;
+    openAtPoint(point: HermesPopoverPoint, targetElement?: HTMLElement): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HermesSignpost, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HermesSignpost, "hermes-signpost", never, { "signpostTriggerAriaLabel": { "alias": "hermesSignpostTriggerAriaLabel"; "required": false; }; "hideTrigger": { "alias": "hermesSignpostHideTrigger"; "required": false; }; }, {}, ["customTrigger"], ["*"], false, [{ directive: typeof i8.HermesPopoverHostDirective; inputs: {}; outputs: {}; }]>;
+}
+
+declare class HermesSignpostContent implements OnDestroy, AfterViewInit {
+    private element;
+    commonStrings: HermesCommonStringsService;
+    private signpostFocusManager;
+    private platformId;
+    private document;
+    private popoverService;
+    private popoverContent;
+    signpostCloseAriaLabel: string;
+    closeButton: ElementRef<HTMLButtonElement>;
+    signpostContentId: string;
+    private _position;
+    constructor(parentHost: ElementRef<HTMLElement>, element: ElementRef, commonStrings: HermesCommonStringsService, signpostIdService: SignpostIdService, signpostFocusManager: SignpostFocusManager, platformId: any, document: Document, popoverService: HermesPopoverService, popoverContent: HermesPopoverContent);
+    /*********
+     *
+     * @description
+     * A setter for the position of the HermesSignpostContent popover. This is a combination of the following:
+     * - originPoint - where on the trigger to position the content
+     * - popoverPoint - where on the content container to align with the origin
+     * - offsetY - where on the Y axis to align the HermesSignpostContent so it meets specs
+     * - offsetX - where on the X axis to align the HermesSignpostContent so it meets specs
+     * There are 12 possible positions to place a HermesSignpostContent container:
+     * - top-left
+     * - top-middle
+     * - top-right
+     * - right-top
+     * - right-middle
+     * - right-bottom
+     * - bottom-right
+     * - bottom-middle
+     * - bottom-left
+     * - left-bottom
+     * - left-middle
+     * - left-top
+     *
+     * I think of it as follows for 'top-left' -> CONTAINER_SIDE-SIDE_POSITION. In this case CONTAINER_SIDE is 'top'
+     * meaning the top of the trigger icon (above the icon that hides/shows) the HermesSignpostContent. And, SIDE_POSITION
+     * is 'left' meaning two things: 1) the HermesSignpostContent container extends to the left and 2) the 'arrow/pointer'
+     * linking the SignpostContent to the trigger points down at the horizontal center of the trigger icon.
+     *
+     * @param newPosition
+     */
+    get position(): string | HermesPopoverPosition;
+    set position(position: string | HermesPopoverPosition);
+    get isOffScreen(): boolean;
+    /**********
+     *
+     * @description
+     * Close function that uses the signpost instance to toggle the state of the content popover.
+     *
+     */
+    close(): void;
+    ngAfterViewInit(): void;
+    onKeyDown(event: KeyboardEvent): void;
+    ngOnDestroy(): void;
+    private getFocusableElements;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HermesSignpostContent, [{ optional: true; }, null, null, null, null, null, null, null, null]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HermesSignpostContent, "hermes-signpost-content", never, { "signpostCloseAriaLabel": { "alias": "hermesSignpostCloseAriaLabel"; "required": false; }; "position": { "alias": "hermesPosition"; "required": false; }; }, {}, never, ["hermes-signpost-title", "*"], false, [{ directive: typeof i8.HermesPopoverContent; inputs: {}; outputs: {}; }]>;
+}
+
+declare class HermesSignpostTitle {
+    static ɵfac: i0.ɵɵFactoryDeclaration<HermesSignpostTitle, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HermesSignpostTitle, "hermes-signpost-title", never, {}, {}, never, ["*"], false, never>;
+}
+
+declare const HERMES_SIGNPOST_DIRECTIVES: Type<any>[];
+declare class HermesSignpostModule {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HermesSignpostModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<HermesSignpostModule, [typeof HermesSignpost, typeof HermesSignpostContent, typeof HermesSignpostTrigger, typeof HermesSignpostTitle], [typeof i5.CommonModule, typeof i6.HermesIcon, typeof i7.HermesFocusOnViewInitModule, typeof i8.HermesPopoverModuleNext, typeof i8.HermesIfOpen], [typeof HermesSignpost, typeof HermesSignpostContent, typeof HermesSignpostTrigger, typeof HermesSignpostTitle, typeof i8.HermesIfOpen]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<HermesSignpostModule>;
+}
+
+export { HERMES_SIGNPOST_DIRECTIVES, HermesSignpost, HermesSignpostContent, HermesSignpostModule, HermesSignpostTitle, HermesSignpostTrigger };
+//# sourceMappingURL=hermes-ui-angular-popover-signpost.d.ts.map

package/types/hermes-ui-angular-popover-signpost.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hermes-ui-angular-popover-signpost.d.ts","sources":["../../../popover/signpost/providers/signpost-focus-manager.service.ts","../../../popover/signpost/providers/signpost-id.service.ts","../../../popover/signpost/signpost-trigger.ts","../../../popover/signpost/signpost.ts","../../../popover/signpost/signpost-content.ts","../../../popover/signpost/signpost-title.ts","../../../popover/signpost/signpost.module.ts"],"mappings":";;;;;;;;;;AASA,cACa,oBAAoB;;AAG/B,yBAAqB,WAAW;;yCAHrB,oBAAoB;6CAApB,oBAAoB;AAYhC;;ACZD,cACa,iBAAiB;;AAG5B,cAAU,UAAU;;yCAHT,iBAAiB;6CAAjB,iBAAiB;AAU7B;;ACND,cAkBa,qBAAsB,YAAW,SAAS;AASnD;AACA;AACA;AACA;AAEqB;AAbvB;;;;;gCAQ0B,oBAAoB,MAChC,UAAU,CAAC,WAAW,sBACP,iBAAiB,wBACd,oBAAoB;;;AAgCpD;;;;AAIG;AAEH,kCAA8B,KAAK;AAInC;yCAtDW,qBAAqB;2CAArB,qBAAqB;AAgEjC;;AClFD,cA+Ba,cAAc;AAkBhB,mBAAe,0BAA0B;AAChD;AAlBF;;;;;;AAMG;AACH;;AAGA;;;AAGG;AACiC;AAG3B,+BAAe,0BAA0B,kBACxB,oBAAoB;AAE9C;;;;;;AAMG;AACH,+BAC2B,qBAAqB;;uBAQ7B,kBAAkB,kBAAkB,WAAW;yCArCvD,cAAc;2CAAd,cAAc,uQAAAA,EAAA,CAAA,0BAAA;AAwC1B;;ACnDD,cA+Ba,qBAAsB,YAAW,SAAS,EAAE,aAAa;AAYlE;AACO,mBAAe,0BAA0B;AAEhD;AACqB;AACH;AAClB;AACA;;AAjB8C,iBAAa,UAAU,CAAC,iBAAiB;AAEzF;;AAOE,4BAAY,UAAU,CAAC,WAAW,YACjB,UAAU,iBACL,0BAA0B,qBAC7B,iBAAiB,wBACN,oBAAoB,6BAEd,QAAQ,kBACpB,oBAAoB,kBACpB,oBAAoB;AAa9C;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4BG;AACH,6BAIgC,qBAAqB;AAArD,oCAAgC,qBAAqB;AAUrD;AAKA;;;;;AAKG;;AAKH;qBAMiB,aAAa;;AAoB9B;yCApHW,qBAAqB;2CAArB,qBAAqB,0QAAAA,EAAA,CAAA,oBAAA;AAyHjC;;AClLD,cAMa,mBAAmB;yCAAnB,mBAAmB;2CAAnB,mBAAmB;AAAG;;ACGnC,cAAa,0BAA0B,EAAE,IAAI;AAO7C,cAKa,oBAAoB;;yCAApB,oBAAoB;0CAApB,oBAAoB,UAAAC,cAAA,SAAAC,qBAAA,SAAAC,qBAAA,SAAAC,mBAAA,WAAA,EAAA,CAAA,YAAA,SAAA,EAAA,CAAA,UAAA,SAAA,EAAA,CAAA,2BAAA,SAAA,EAAA,CAAA,uBAAA,SAAA,EAAA,CAAA,YAAA,WAAAH,cAAA,SAAAC,qBAAA,SAAAC,qBAAA,SAAAC,mBAAA,SAAA,EAAA,CAAA,YAAA;0CAApB,oBAAoB;AAIhC;;","names":["i1","i1.HermesSignpost","i2.HermesSignpostContent","i3.HermesSignpostTrigger","i4.HermesSignpostTitle"]}

package/types/hermes-ui-angular-popover-tooltip.d.ts

@@ -0,0 +1,84 @@
+import * as i0 from '@angular/core';
+import { ElementRef, OnInit, Renderer2, Type } from '@angular/core';
+import * as i1 from '@hermes-ui/angular/popover/common';
+import { HermesPopoverService, HermesPopoverContent, HermesPopoverPosition } from '@hermes-ui/angular/popover/common';
+import { Observable } from 'rxjs';
+import * as i4 from '@angular/common';
+import * as i5 from '@hermes-ui/angular/icon';
+
+declare class HermesTooltip {
+    static ɵfac: i0.ɵɵFactoryDeclaration<HermesTooltip, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HermesTooltip, "hermes-tooltip", never, {}, {}, never, ["*"], false, [{ directive: typeof i1.HermesPopoverHostDirective; inputs: {}; outputs: {}; }]>;
+}
+
+declare class TooltipIdService {
+    private _id;
+    get id(): Observable<string>;
+    updateId(id: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TooltipIdService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TooltipIdService>;
+}
+
+declare class TooltipMouseService {
+    private readonly popoverService;
+    private mouseOutDelay;
+    private mouseOverTrigger;
+    private mouseOverContent;
+    constructor(popoverService: HermesPopoverService);
+    onMouseEnterTrigger(): void;
+    onMouseLeaveTrigger(): void;
+    onMouseEnterContent(): void;
+    onMouseLeaveContent(): void;
+    private hideIfMouseOut;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TooltipMouseService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TooltipMouseService>;
+}
+
+declare class HermesTooltipTrigger {
+    private popoverService;
+    private tooltipMouseService;
+    ariaDescribedBy: string;
+    private subs;
+    constructor(popoverService: HermesPopoverService, tooltipIdService: TooltipIdService, tooltipMouseService: TooltipMouseService, element: ElementRef);
+    ngOnDestroy(): void;
+    showTooltip(): void;
+    hideTooltip(): void;
+    private onMouseEnter;
+    private onMouseLeave;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HermesTooltipTrigger, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HermesTooltipTrigger, "[hermesTooltipTrigger]", never, {}, {}, never, never, false, never>;
+}
+
+declare class HermesTooltipContent implements OnInit {
+    private tooltipIdService;
+    el: ElementRef;
+    private renderer;
+    private tooltipMouseService;
+    private popoverContent;
+    private _id;
+    private _position;
+    private _size;
+    constructor(parentHost: ElementRef<HTMLElement>, tooltipIdService: TooltipIdService, el: ElementRef, renderer: Renderer2, popoverService: HermesPopoverService, tooltipMouseService: TooltipMouseService, popoverContent: HermesPopoverContent);
+    get id(): string;
+    set id(value: string);
+    get position(): string | HermesPopoverPosition;
+    set position(value: string | HermesPopoverPosition);
+    get size(): string;
+    set size(value: string);
+    ngOnInit(): void;
+    private onMouseEnter;
+    private onMouseLeave;
+    private updateCssClass;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HermesTooltipContent, [{ optional: true; }, null, null, null, null, null, null]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HermesTooltipContent, "hermes-tooltip-content", never, { "id": { "alias": "id"; "required": false; }; "position": { "alias": "hermesPosition"; "required": false; }; "size": { "alias": "hermesSize"; "required": false; }; }, {}, never, ["*"], false, [{ directive: typeof i1.HermesPopoverContent; inputs: {}; outputs: {}; }]>;
+}
+
+declare const HERMES_TOOLTIP_DIRECTIVES: Type<any>[];
+declare class HermesTooltipModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<HermesTooltipModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<HermesTooltipModule, [typeof HermesTooltip, typeof HermesTooltipTrigger, typeof HermesTooltipContent], [typeof i4.CommonModule, typeof i5.HermesIcon, typeof i1.HermesPopoverModuleNext], [typeof HermesTooltip, typeof HermesTooltipTrigger, typeof HermesTooltipContent, typeof i1.HermesIfOpen, typeof i5.HermesIcon]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<HermesTooltipModule>;
+}
+
+export { HERMES_TOOLTIP_DIRECTIVES, HermesTooltip, HermesTooltipContent, HermesTooltipModule, HermesTooltipTrigger };
+//# sourceMappingURL=hermes-ui-angular-popover-tooltip.d.ts.map

package/types/hermes-ui-angular-popover-tooltip.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hermes-ui-angular-popover-tooltip.d.ts","sources":["../../../popover/tooltip/tooltip.ts","../../../popover/tooltip/providers/tooltip-id.service.ts","../../../popover/tooltip/providers/tooltip-mouse.service.ts","../../../popover/tooltip/tooltip-trigger.ts","../../../popover/tooltip/tooltip-content.ts","../../../popover/tooltip/tooltip.module.ts"],"mappings":";;;;;;;;AAaA,cAUa,aAAa;yCAAb,aAAa;2CAAb,aAAa,6EAAA,EAAA,CAAA,0BAAA;AAAG;;ACb7B,cACa,gBAAgB;;AAG3B,cAAU,UAAU;;yCAHT,gBAAgB;6CAAhB,gBAAgB;AAU5B;;ACXD,cACa,mBAAmB;;;;;AAKD,gCAAgB,oBAAoB;;;;;AAqBjE;yCA1BW,mBAAmB;6CAAnB,mBAAmB;AAmC/B;;AChCD,cAUa,oBAAoB;AAK7B;AAEA;;;AAFQ,gCAAgB,oBAAoB,oBAC1B,gBAAgB,uBACL,mBAAmB,WACvC,UAAU;;AAYrB;AAKA;AAKA;AAKA;yCAnCW,oBAAoB;2CAApB,oBAAoB;AAsChC;;ACpCD,cAYa,oBAAqB,YAAW,MAAM;AAS/C;AACO,QAAI,UAAU;AACrB;AAEA;AACA;;;;AANA,4BAAY,UAAU,CAAC,WAAW,qBACR,gBAAgB,MAC/B,UAAU,YACH,SAAS,kBACX,oBAAoB,uBACP,mBAAmB,kBACxB,oBAAoB;;AAmB9C;AAOA,6BAI6B,qBAAqB;AAAlD,iCAA6B,qBAAqB;;AAYlD;;AAcA;AAKA;AAIA;yCA/EW,oBAAoB;2CAApB,oBAAoB,yPAAA,EAAA,CAAA,oBAAA;AAmFhC;;ACzGD,cAAa,yBAAyB,EAAE,IAAI;AAE5C,cAKa,mBAAmB;yCAAnB,mBAAmB;0CAAnB,mBAAmB,UAAAA,aAAA,SAAAC,oBAAA,SAAAC,oBAAA,WAAA,EAAA,CAAA,YAAA,SAAA,EAAA,CAAA,UAAA,SAAAC,EAAA,CAAA,uBAAA,WAAAH,aAAA,SAAAC,oBAAA,SAAAC,oBAAA,SAAAC,EAAA,CAAA,YAAA,SAAA,EAAA,CAAA,UAAA;0CAAnB,mBAAmB;AAAG;;","names":["i1.HermesTooltip","i2.HermesTooltipTrigger","i3.HermesTooltipContent","i6"]}

package/types/hermes-ui-angular-popover.d.ts

@@ -0,0 +1,17 @@
+import * as i1 from '@hermes-ui/angular/popover/dropdown';
+export * from '@hermes-ui/angular/popover/dropdown';
+export * from '@hermes-ui/angular/popover/common';
+import * as i0 from '@angular/core';
+import * as i2 from '@hermes-ui/angular/popover/signpost';
+export * from '@hermes-ui/angular/popover/signpost';
+import * as i3 from '@hermes-ui/angular/popover/tooltip';
+export * from '@hermes-ui/angular/popover/tooltip';
+
+declare class HermesPopoverModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<HermesPopoverModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<HermesPopoverModule, never, never, [typeof i1.HermesDropdownModule, typeof i2.HermesSignpostModule, typeof i3.HermesTooltipModule]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<HermesPopoverModule>;
+}
+
+export { HermesPopoverModule };
+//# sourceMappingURL=hermes-ui-angular-popover.d.ts.map

package/types/hermes-ui-angular-popover.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hermes-ui-angular-popover.d.ts","sources":["../../../popover/popover.module.ts"],"mappings":";;;;;;;;;AAYA,cAGa,mBAAmB;yCAAnB,mBAAmB;0CAAnB,mBAAmB,wBAAA,EAAA,CAAA,oBAAA,SAAA,EAAA,CAAA,oBAAA,SAAA,EAAA,CAAA,mBAAA;0CAAnB,mBAAmB;AAAG;;","names":[]}

package/types/hermes-ui-angular-progress-progress-bars.d.ts

@@ -0,0 +1,58 @@
+import * as i0 from '@angular/core';
+import { Type } from '@angular/core';
+import * as i2 from '@angular/common';
+
+declare class HermesProgressBar {
+    max: number | string;
+    displayval: string;
+    color: string;
+    value: number | string;
+    externalId: string;
+    private _ID;
+    private _labeled;
+    private _fade;
+    private _loop;
+    private _flash;
+    private _flashDanger;
+    private _compact;
+    get id(): string;
+    set id(value: string);
+    get progressClass(): boolean;
+    set hermesCompact(value: boolean | string);
+    get compactClass(): boolean;
+    set hermesLabeled(value: boolean | string);
+    get labeledClass(): boolean;
+    set hermesFade(value: boolean | string);
+    get fadeClass(): boolean;
+    set hermesLoop(value: boolean | string);
+    get loopClass(): boolean;
+    get warningClass(): boolean;
+    get successClass(): boolean;
+    get dangerClass(): boolean;
+    set hermesFlash(value: boolean | string);
+    get flashClass(): boolean;
+    /** @deprecated since 2.0, remove in 4.0 */
+    set hermesFlashDanger(value: boolean | string);
+    get flashDangerClass(): boolean;
+    /**
+     * Make sure that we always will have something that is readable
+     * for the screen reader
+     */
+    get displayValue(): string;
+    /**
+     * Display optional text only when labeled is eneabled
+     */
+    displayStringValue(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HermesProgressBar, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HermesProgressBar, "hermes-progress-bar", never, { "max": { "alias": "hermesMax"; "required": false; }; "displayval": { "alias": "hermesDisplayval"; "required": false; }; "color": { "alias": "hermesColor"; "required": false; }; "value": { "alias": "hermesValue"; "required": false; }; "id": { "alias": "id"; "required": false; }; "hermesCompact": { "alias": "hermesCompact"; "required": false; }; "hermesLabeled": { "alias": "hermesLabeled"; "required": false; }; "hermesFade": { "alias": "hermesFade"; "required": false; }; "hermesLoop": { "alias": "hermesLoop"; "required": false; }; "hermesFlash": { "alias": "hermesFlash"; "required": false; }; "hermesFlashDanger": { "alias": "hermesFlashDanger"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare const HERMES_PROGRESS_BAR_DIRECTIVES: Type<any>[];
+declare class HermesProgressBarModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<HermesProgressBarModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<HermesProgressBarModule, [typeof HermesProgressBar], [typeof i2.CommonModule], [typeof HermesProgressBar]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<HermesProgressBarModule>;
+}
+
+export { HERMES_PROGRESS_BAR_DIRECTIVES, HermesProgressBar, HermesProgressBarModule };
+//# sourceMappingURL=hermes-ui-angular-progress-progress-bars.d.ts.map

package/types/hermes-ui-angular-progress-progress-bars.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hermes-ui-angular-progress-progress-bars.d.ts","sources":["../../../progress/progress-bars/progress-bar.ts","../../../progress/progress-bars/progress-bar.module.ts"],"mappings":";;;;AAUA,cAUa,iBAAiB;AACR;;;AAWE;AAEE;;;;;;;;;AAcxB;AAKA;AAKA;AAKA;AAKA;AAKA;AAKA;AAKA;AAKA;AAKA;AAKA;AAKA;AAKA;AAKA;AAKA;;AAMA;AAKA;AAKA;;;AAGG;AACH;AAOA;;AAEG;;yCA/HQ,iBAAiB;2CAAjB,iBAAiB;AAmI7B;;AC3ID,cAAa,8BAA8B,EAAE,IAAI;AAEjD,cAKa,uBAAuB;yCAAvB,uBAAuB;0CAAvB,uBAAuB,UAAAA,iBAAA,WAAA,EAAA,CAAA,YAAA,WAAAA,iBAAA;0CAAvB,uBAAuB;AAAG;;","names":["i1.HermesProgressBar"]}

package/types/hermes-ui-angular-progress-spinner.d.ts

@@ -0,0 +1,45 @@
+import * as i0 from '@angular/core';
+import { Type } from '@angular/core';
+import * as i2 from '@angular/common';
+
+declare class HermesSpinner {
+    private _inline;
+    private _inverse;
+    private _small;
+    private _medium;
+    /**
+     * Default class for all spinners. This class is always true
+     */
+    get spinnerClass(): boolean;
+    get inlineClass(): boolean;
+    set hermesInline(value: boolean | string);
+    get inverseClass(): boolean;
+    set hermesInverse(value: boolean | string);
+    get smallClass(): boolean;
+    set hermesSmall(value: boolean | string);
+    /**
+     * When hermesSmall & hermesMedium are set both to true.
+     * The CSS with high priority will be small - so medium size will be ignored.
+     *
+     * For this reason if hermesSmall is set we won't add hermesMedium class.
+     *
+     * NOTE: This is dictated by the CSS rules.
+     * DON'T USE hermesSmall & hermesMedium to toggle classes. This could change without notice.
+     *
+     * Also there is no logical need to have both of them set to TRUE or FALSE.
+     */
+    get mediumClass(): boolean;
+    set hermesMedium(value: boolean | string);
+    static ɵfac: i0.ɵɵFactoryDeclaration<HermesSpinner, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HermesSpinner, "hermes-spinner", never, { "hermesInline": { "alias": "hermesInline"; "required": false; }; "hermesInverse": { "alias": "hermesInverse"; "required": false; }; "hermesSmall": { "alias": "hermesSmall"; "required": false; }; "hermesMedium": { "alias": "hermesMedium"; "required": false; }; }, {}, never, ["*"], false, never>;
+}
+
+declare const HERMES_SPINNER_DIRECTIVES: Type<any>[];
+declare class HermesSpinnerModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<HermesSpinnerModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<HermesSpinnerModule, [typeof HermesSpinner], [typeof i2.CommonModule], [typeof HermesSpinner]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<HermesSpinnerModule>;
+}
+
+export { HERMES_SPINNER_DIRECTIVES, HermesSpinner, HermesSpinnerModule };
+//# sourceMappingURL=hermes-ui-angular-progress-spinner.d.ts.map

package/types/hermes-ui-angular-progress-spinner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hermes-ui-angular-progress-spinner.d.ts","sources":["../../../progress/spinner/spinner.ts","../../../progress/spinner/spinner.module.ts"],"mappings":";;;;AAUA,cAQa,aAAa;;;;;AAMxB;;AAEG;AACH;AAKA;AAKA;AAKA;AAKA;AAKA;AAKA;AAKA;;;;;;;;;;AAUG;AACH;AAQA;yCA/DW,aAAa;2CAAb,aAAa;AAmEzB;;ACzED,cAAa,yBAAyB,EAAE,IAAI;AAE5C,cAKa,mBAAmB;yCAAnB,mBAAmB;0CAAnB,mBAAmB,UAAAA,aAAA,WAAA,EAAA,CAAA,YAAA,WAAAA,aAAA;0CAAnB,mBAAmB;AAAG;;","names":["i1.HermesSpinner"]}