@hermes-ui/angular 0.1.4

package/types/hermes-ui-angular-layout-vertical-nav.d.ts

@@ -0,0 +1,129 @@
+import * as i0 from '@angular/core';
+import { AfterContentInit, OnDestroy, EventEmitter, ElementRef, ChangeDetectorRef, Type } from '@angular/core';
+import { AnimationEvent } from '@angular/animations';
+import * as i8 from '@hermes-ui/angular/utils';
+import { HermesCommonStringsService, IfExpandService } from '@hermes-ui/angular/utils';
+import { Observable } from 'rxjs';
+import * as i6 from '@angular/common';
+import * as i7 from '@hermes-ui/angular/icon';
+
+declare class HermesVerticalNavGroupChildren {
+    static ɵfac: i0.ɵɵFactoryDeclaration<HermesVerticalNavGroupChildren, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HermesVerticalNavGroupChildren, "hermes-vertical-nav-group-children", never, {}, {}, never, ["*"], false, never>;
+}
+
+declare class VerticalNavGroupRegistrationService {
+    navGroupCount: number;
+    registerNavGroup(): void;
+    unregisterNavGroup(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VerticalNavGroupRegistrationService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<VerticalNavGroupRegistrationService>;
+}
+
+declare class VerticalNavGroupService {
+    private _expandChange;
+    get expandChange(): Observable<boolean>;
+    expand(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VerticalNavGroupService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<VerticalNavGroupService>;
+}
+
+declare class VerticalNavService {
+    private _animateOnCollapsed;
+    private _collapsedChanged;
+    private _collapsed;
+    private _collapsible;
+    get animateOnCollapsed(): Observable<boolean>;
+    get collapsedChanged(): Observable<boolean>;
+    get collapsed(): boolean;
+    set collapsed(value: boolean);
+    get collapsible(): boolean;
+    set collapsible(value: boolean);
+    private updateCollapseBehavior;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VerticalNavService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<VerticalNavService>;
+}
+
+declare class HermesVerticalNavGroup implements AfterContentInit, OnDestroy {
+    private _itemExpand;
+    private _navGroupRegistrationService;
+    private _navService;
+    commonStrings: HermesCommonStringsService;
+    expandedChange: EventEmitter<boolean>;
+    private wasExpanded;
+    private _subscriptions;
+    private _expandAnimationState;
+    constructor(_itemExpand: IfExpandService, _navGroupRegistrationService: VerticalNavGroupRegistrationService, navGroupService: VerticalNavGroupService, _navService: VerticalNavService, commonStrings: HermesCommonStringsService);
+    get expanded(): boolean;
+    set expanded(value: boolean);
+    set userExpandedInput(value: boolean | string);
+    get expandAnimationState(): string;
+    set expandAnimationState(value: string);
+    ngAfterContentInit(): void;
+    ngOnDestroy(): void;
+    expandGroup(): void;
+    collapseGroup(): void;
+    expandAnimationDone($event: AnimationEvent): void;
+    toggleExpand(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HermesVerticalNavGroup, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HermesVerticalNavGroup, "hermes-vertical-nav-group", never, { "userExpandedInput": { "alias": "hermesVerticalNavGroupExpanded"; "required": false; }; }, { "expandedChange": "hermesVerticalNavGroupExpandedChange"; }, never, ["[hermesVerticalNavLink]", "[hermesVerticalNavIcon]", "*", "[hermesIfExpanded], hermes-vertical-nav-group-children"], false, never>;
+}
+
+declare class VerticalNavIconService {
+    private _icons;
+    get hasIcons(): boolean;
+    registerIcon(): void;
+    unregisterIcon(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VerticalNavIconService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<VerticalNavIconService>;
+}
+
+declare class HermesVerticalNav implements OnDestroy {
+    private _navService;
+    private _navIconService;
+    private _navGroupRegistrationService;
+    commonStrings: HermesCommonStringsService;
+    toggleLabel: string;
+    contentId: string;
+    private _collapsedChanged;
+    private _sub;
+    constructor(_navService: VerticalNavService, _navIconService: VerticalNavIconService, _navGroupRegistrationService: VerticalNavGroupRegistrationService, commonStrings: HermesCommonStringsService);
+    get collapsible(): boolean | string;
+    set collapsible(value: boolean | string);
+    get collapsed(): boolean | string;
+    set collapsed(value: boolean | string);
+    get hasNavGroups(): boolean;
+    get hasIcons(): boolean;
+    get ariaExpanded(): string;
+    ngOnDestroy(): void;
+    toggleByButton(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HermesVerticalNav, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HermesVerticalNav, "hermes-vertical-nav", never, { "toggleLabel": { "alias": "hermesVerticalNavToggleLabel"; "required": false; }; "collapsible": { "alias": "hermesVerticalNavCollapsible"; "required": false; }; "collapsed": { "alias": "hermesVerticalNavCollapsed"; "required": false; }; }, { "_collapsedChanged": "hermesVerticalNavCollapsedChange"; }, never, ["*"], false, never>;
+}
+
+declare class HermesVerticalNavLink implements OnDestroy {
+    private destroy$;
+    constructor(host: ElementRef<HTMLElement>, ref: ChangeDetectorRef, navGroupService: VerticalNavGroupService | null);
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HermesVerticalNavLink, [null, null, { optional: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HermesVerticalNavLink, "[hermesVerticalNavLink]", never, {}, {}, never, ["[hermesVerticalNavIcon]", "*"], false, never>;
+}
+
+declare class HermesVerticalNavIcon implements OnDestroy {
+    private _verticalNavIconService;
+    constructor(_verticalNavIconService: VerticalNavIconService);
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HermesVerticalNavIcon, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HermesVerticalNavIcon, "[hermesVerticalNavIcon]", never, {}, {}, never, never, false, never>;
+}
+
+declare const HERMES_VERTICAL_NAV_DIRECTIVES: Type<any>[];
+declare class HermesVerticalNavModule {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HermesVerticalNavModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<HermesVerticalNavModule, [typeof HermesVerticalNav, typeof HermesVerticalNavLink, typeof HermesVerticalNavGroup, typeof HermesVerticalNavGroupChildren, typeof HermesVerticalNavIcon], [typeof i6.CommonModule, typeof i7.HermesIcon, typeof i8.HermesConditionalModule, typeof i8.HermesFocusOnViewInitModule], [typeof HermesVerticalNav, typeof HermesVerticalNavLink, typeof HermesVerticalNavGroup, typeof HermesVerticalNavGroupChildren, typeof HermesVerticalNavIcon, typeof i8.HermesConditionalModule, typeof i7.HermesIcon, typeof i8.HermesFocusOnViewInitModule]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<HermesVerticalNavModule>;
+}
+
+export { HERMES_VERTICAL_NAV_DIRECTIVES, HermesVerticalNav, HermesVerticalNavGroup, HermesVerticalNavGroupChildren, HermesVerticalNavIcon, HermesVerticalNavLink, HermesVerticalNavModule };
+//# sourceMappingURL=hermes-ui-angular-layout-vertical-nav.d.ts.map

package/types/hermes-ui-angular-layout-vertical-nav.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hermes-ui-angular-layout-vertical-nav.d.ts","sources":["../../../layout/vertical-nav/vertical-nav-group-children.ts","../../../layout/vertical-nav/providers/vertical-nav-group-registration.service.ts","../../../layout/vertical-nav/providers/vertical-nav-group.service.ts","../../../layout/vertical-nav/providers/vertical-nav.service.ts","../../../layout/vertical-nav/vertical-nav-group.ts","../../../layout/vertical-nav/providers/vertical-nav-icon.service.ts","../../../layout/vertical-nav/vertical-nav.ts","../../../layout/vertical-nav/vertical-nav-link.ts","../../../layout/vertical-nav/vertical-nav-icon.ts","../../../layout/vertical-nav/vertical-nav.module.ts"],"mappings":";;;;;;;;;AASA,cAKa,8BAA8B;yCAA9B,8BAA8B;2CAA9B,8BAA8B;AAAG;;ACL9C,cACa,mCAAmC;AAC9C;;AAMA;yCAPW,mCAAmC;6CAAnC,mCAAmC;AAU/C;;ACVD,cACa,uBAAuB;;AAGlC,wBAAoB,UAAU;AAI9B;yCAPW,uBAAuB;6CAAvB,uBAAuB;AAUnC;;ACXD,cACa,kBAAkB;;;;;AAM7B,8BAA0B,UAAU;AAIpC,4BAAwB,UAAU;;AAOlC;;AAUA;AAUA;yCArCW,kBAAkB;6CAAlB,kBAAkB;AA0C9B;;AClCD,cAca,sBAAuB,YAAW,gBAAgB,EAAE,SAAS;AAQtE;AACA;AAEA;AACO,mBAAe,0BAA0B;AAXF,oBAAc,YAAA;;;;AAOpD,6BAAa,eAAe,gCACE,mCAAmC,mBACxD,uBAAuB,eACnB,kBAAkB,iBACjB,0BAA0B;;AAmDlD;AAOA;;AAcA;;;AAoBA;AAMA;gCAO4B,cAAc;AAM1C;yCA3HW,sBAAsB;2CAAtB,sBAAsB;AAuIlC;;AC/JD,cACa,sBAAsB;;;AAOjC;AAIA;yCAXW,sBAAsB;6CAAtB,sBAAsB;AAclC;;ACTD,cAYa,iBAAkB,YAAW,SAAS;AAS/C;AACA;AACA;AACO,mBAAe,0BAA0B;;AAVlD;;;AAOU,6BAAa,kBAAkB,mBACd,sBAAsB,gCACT,mCAAmC,iBACnD,0BAA0B;AAOlD;AAIA;AAIA;AAIA;;;;;;yCA/BW,iBAAiB;2CAAjB,iBAAiB;AAyD7B;;ACvED,cAaa,qBAAsB,YAAW,SAAS;;AAInD,sBAAM,UAAU,CAAC,WAAW,QACvB,iBAAiB,mBACwC,uBAAuB;AAavF;yCAnBW,qBAAqB;2CAArB,qBAAqB;AAsBjC;;ACrCD,cAKa,qBAAsB,YAAW,SAAS;AACzC;AAAQ,yCAAyB,sBAAsB;;yCADxD,qBAAqB;2CAArB,qBAAqB;AAQjC;;ACND,cAAa,8BAA8B,EAAE,IAAI;AAQjD,cAKa,uBAAuB;;yCAAvB,uBAAuB;0CAAvB,uBAAuB,UAAAA,iBAAA,SAAAC,qBAAA,SAAAC,sBAAA,SAAAC,8BAAA,SAAAC,qBAAA,WAAA,EAAA,CAAA,YAAA,SAAA,EAAA,CAAA,UAAA,SAAA,EAAA,CAAA,uBAAA,SAAA,EAAA,CAAA,2BAAA,WAAAJ,iBAAA,SAAAC,qBAAA,SAAAC,sBAAA,SAAAC,8BAAA,SAAAC,qBAAA,SAAA,EAAA,CAAA,uBAAA,SAAA,EAAA,CAAA,UAAA,SAAA,EAAA,CAAA,2BAAA;0CAAvB,uBAAuB;AAInC;;","names":["i1.HermesVerticalNav","i2.HermesVerticalNavLink","i3.HermesVerticalNavGroup","i4.HermesVerticalNavGroupChildren","i5.HermesVerticalNavIcon"]}

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

@@ -0,0 +1,20 @@
+import * as i0 from '@angular/core';
+import * as i1 from '@hermes-ui/angular/layout/main-container';
+export * from '@hermes-ui/angular/layout/main-container';
+import * as i2 from '@hermes-ui/angular/layout/nav';
+export * from '@hermes-ui/angular/layout/nav';
+import * as i3 from '@hermes-ui/angular/layout/tabs';
+export * from '@hermes-ui/angular/layout/tabs';
+import * as i4 from '@hermes-ui/angular/layout/vertical-nav';
+export * from '@hermes-ui/angular/layout/vertical-nav';
+import * as i5 from '@hermes-ui/angular/layout/breadcrumbs';
+export * from '@hermes-ui/angular/layout/breadcrumbs';
+
+declare class HermesLayoutModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<HermesLayoutModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<HermesLayoutModule, never, never, [typeof i1.HermesMainContainerModule, typeof i2.HermesNavigationModule, typeof i3.HermesTabsModule, typeof i4.HermesVerticalNavModule, typeof i5.HermesBreadcrumbsModule]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<HermesLayoutModule>;
+}
+
+export { HermesLayoutModule };
+//# sourceMappingURL=hermes-ui-angular-layout.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"hermes-ui-angular-layout.d.ts","sources":["../../../layout/layout.module.ts"],"mappings":";;;;;;;;;;;;AAcA,cAGa,kBAAkB;yCAAlB,kBAAkB;0CAAlB,kBAAkB,wBAAA,EAAA,CAAA,yBAAA,SAAA,EAAA,CAAA,sBAAA,SAAA,EAAA,CAAA,gBAAA,SAAA,EAAA,CAAA,uBAAA,SAAA,EAAA,CAAA,uBAAA;0CAAlB,kBAAkB;AAAG;;","names":[]}

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

@@ -0,0 +1,161 @@
+import { AnimationEvent } from '@angular/animations';
+import * as i0 from '@angular/core';
+import { OnChanges, OnDestroy, ElementRef, EventEmitter, TemplateRef, SimpleChange, Renderer2, NgZone, Type, OnInit } from '@angular/core';
+import * as i5 from '@hermes-ui/angular/utils';
+import { HermesCommonStringsService, ScrollingService } from '@hermes-ui/angular/utils';
+import * as i4 from '@angular/common';
+import * as i6 from '@hermes-ui/angular/icon';
+
+declare class HermesModalConfigurationService {
+    fadeMove: string;
+    backdrop: boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HermesModalConfigurationService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<HermesModalConfigurationService>;
+}
+
+interface Closable {
+    close(): void;
+}
+declare class ModalStackService {
+    private readonly platformId;
+    private readonly modalStack;
+    private readonly keyUpEventListener;
+    constructor(platformId: unknown);
+    trackModalOpen(openedModal: Closable): void;
+    trackModalClose(closedModal: Closable): void;
+    private onKeyUp;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ModalStackService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ModalStackService>;
+}
+
+declare class HermesModal implements OnChanges, OnDestroy {
+    private _scrollingService;
+    commonStrings: HermesCommonStringsService;
+    private modalStackService;
+    private configuration;
+    modalId: string;
+    title: ElementRef<HTMLElement>;
+    _open: boolean;
+    _openChanged: EventEmitter<boolean>;
+    closable: boolean;
+    closeButtonAriaLabel: string;
+    size: string;
+    staticBackdrop: boolean;
+    skipAnimation: boolean;
+    stopClose: boolean;
+    altClose: EventEmitter<boolean>;
+    labelledBy: string;
+    bypassScrollService: boolean;
+    protected readonly modalContentTemplate: TemplateRef<any>;
+    private readonly bodyElementRef;
+    constructor(_scrollingService: ScrollingService, commonStrings: HermesCommonStringsService, modalStackService: ModalStackService, configuration: HermesModalConfigurationService);
+    get fadeMove(): string;
+    set fadeMove(move: string);
+    get backdrop(): boolean;
+    ngOnChanges(changes: {
+        [propName: string]: SimpleChange;
+    }): void;
+    ngOnDestroy(): void;
+    open(): void;
+    backdropClick(): void;
+    close(): void;
+    fadeDone(e: AnimationEvent): void;
+    scrollTop(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HermesModal, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HermesModal, "hermes-modal", never, { "_open": { "alias": "hermesModalOpen"; "required": false; }; "closable": { "alias": "hermesModalClosable"; "required": false; }; "closeButtonAriaLabel": { "alias": "hermesModalCloseButtonAriaLabel"; "required": false; }; "size": { "alias": "hermesModalSize"; "required": false; }; "staticBackdrop": { "alias": "hermesModalStaticBackdrop"; "required": false; }; "skipAnimation": { "alias": "hermesModalSkipAnimation"; "required": false; }; "stopClose": { "alias": "hermesModalPreventClose"; "required": false; }; "labelledBy": { "alias": "hermesModalLabelledById"; "required": false; }; "bypassScrollService": { "alias": "hermesModalOverrideScrollService"; "required": false; }; }, { "_openChanged": "hermesModalOpenChange"; "altClose": "hermesModalAlternateClose"; }, ["modalContentTemplate"], [".leading-button", ".modal-title", ".modal-body", ".modal-footer"], false, never>;
+}
+
+/**
+ * Allows modal overflow area to be scrollable via keyboard.
+ * The modal body will focus with keyboard navigation only.
+ * This allows inner focusable items to be focused without
+ * the overflow scroll being focused.
+ */
+declare class HermesModalBody implements OnDestroy {
+    private readonly renderer;
+    private readonly host;
+    private tabindex;
+    private unlisteners;
+    private observer;
+    constructor(renderer: Renderer2, host: ElementRef<HTMLElement>, ngZone: NgZone);
+    ngOnDestroy(): void;
+    private addTabIndex;
+    private removeTabIndex;
+    private addOrRemoveTabIndex;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HermesModalBody, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HermesModalBody, ".modal-body", never, {}, {}, never, never, false, never>;
+}
+
+declare class HermesModalHostComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<HermesModalHostComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HermesModalHostComponent, "[hermesModalHost]", never, {}, {}, never, ["*"], false, never>;
+}
+
+declare const HERMES_MODAL_DIRECTIVES: Type<any>[];
+declare class HermesModalModule {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HermesModalModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<HermesModalModule, [typeof HermesModal, typeof HermesModalBody, typeof HermesModalHostComponent], [typeof i4.CommonModule, typeof i5.CdkTrapFocusModule, typeof i6.HermesIcon], [typeof HermesModal, typeof HermesModalBody, typeof HermesModalHostComponent, typeof i6.HermesIcon]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<HermesModalModule>;
+}
+
+declare class HermesSidePanel implements OnInit, OnDestroy {
+    private element;
+    private configuration;
+    commonStrings: HermesCommonStringsService;
+    openChange: EventEmitter<boolean>;
+    closeButtonAriaLabel: string | undefined;
+    skipAnimation: boolean;
+    labelledById: string;
+    staticBackdrop: boolean;
+    closable: boolean;
+    preventClose: boolean;
+    altClose: EventEmitter<boolean>;
+    private _pinnable;
+    private _pinned;
+    private originalStopClose;
+    private _position;
+    private _modal;
+    private __open;
+    private _size;
+    constructor(element: ElementRef<HTMLElement>, configuration: HermesModalConfigurationService, commonStrings: HermesCommonStringsService);
+    get _open(): boolean;
+    set _open(open: boolean);
+    get size(): string;
+    set size(value: string);
+    get position(): string;
+    set position(position: string);
+    get pinned(): boolean;
+    set pinned(pinned: boolean);
+    get hermesSidePanelBackdrop(): boolean;
+    set hermesSidePanelBackdrop(backdrop: boolean);
+    get hermesSidePanelPinnable(): boolean;
+    set hermesSidePanelPinnable(pinnable: boolean);
+    private get modal();
+    private set modal(value);
+    private get hostElement();
+    private get bottomPositionCssClass();
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    handleModalOpen(open: boolean): void;
+    open(): void;
+    close(): void;
+    togglePinned(): void;
+    private documentClick;
+    private updateModalState;
+    private cleanupPinnedClasses;
+    private updatePinnedClasses;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HermesSidePanel, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HermesSidePanel, "hermes-side-panel", never, { "closeButtonAriaLabel": { "alias": "hermesSidePanelCloseButtonAriaLabel"; "required": false; }; "skipAnimation": { "alias": "hermesSidePanelSkipAnimation"; "required": false; }; "labelledById": { "alias": "hermesSidePanelLabelledById"; "required": false; }; "staticBackdrop": { "alias": "hermesSidePanelStaticBackdrop"; "required": false; }; "closable": { "alias": "hermesSidePanelClosable"; "required": false; }; "preventClose": { "alias": "hermesSidePanelPreventClose"; "required": false; }; "_open": { "alias": "hermesSidePanelOpen"; "required": false; }; "size": { "alias": "hermesSidePanelSize"; "required": false; }; "position": { "alias": "hermesSidePanelPosition"; "required": false; }; "pinned": { "alias": "hermesSidePanelPinned"; "required": false; }; "hermesSidePanelBackdrop": { "alias": "hermesSidePanelBackdrop"; "required": false; }; "hermesSidePanelPinnable": { "alias": "hermesSidePanelPinnable"; "required": false; }; }, { "openChange": "hermesSidePanelOpenChange"; "altClose": "hermesSidePanelAlternateClose"; }, never, [".side-panel-title", ".side-panel-body", ".side-panel-footer"], false, never>;
+}
+
+declare const HERMES_SIDEPANEL_DIRECTIVES: Type<any>[];
+declare class HermesSidePanelModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<HermesSidePanelModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<HermesSidePanelModule, [typeof HermesSidePanel], [typeof i4.CommonModule, typeof i5.CdkTrapFocusModule, typeof i6.HermesIcon, typeof HermesModalModule], [typeof HermesSidePanel, typeof HermesModalModule, typeof i6.HermesIcon]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<HermesSidePanelModule>;
+}
+
+export { HERMES_MODAL_DIRECTIVES, HERMES_SIDEPANEL_DIRECTIVES, HermesModal, HermesModalBody, HermesModalConfigurationService, HermesModalHostComponent, HermesModalModule, HermesSidePanel, HermesSidePanelModule, ModalStackService };
+export type { Closable };
+//# sourceMappingURL=hermes-ui-angular-modal.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"hermes-ui-angular-modal.d.ts","sources":["../../../modal/modal-configuration.service.ts","../../../modal/modal-stack.service.ts","../../../modal/modal.ts","../../../modal/modal-body.ts","../../../modal/modal-host.component.ts","../../../modal/modal.module.ts","../../../modal/side-panel.ts","../../../modal/side-panel.module.ts"],"mappings":";;;;;;;;AASA,cACa,+BAA+B;AAC1C;AACA;yCAFW,+BAA+B;6CAA/B,+BAA+B;AAG3C;;UCFgB,QAAQ;;AAExB;AAED,cACa,iBAAiB;;AAC5B;AACA;AAEkD;gCAEtB,QAAQ;iCAUP,QAAQ;AAYrC;yCA5BW,iBAAiB;6CAAjB,iBAAiB;AAqC7B;;AC1BD,cAmCa,WAAY,YAAW,SAAS,EAAE,SAAS;AA2BpD;AACO,mBAAe,0BAA0B;AAChD;AACA;AA7BF;AACoB,WAAO,UAAU,CAAC,WAAW;AAEI;AACpB,kBAAY,YAAA;AAEf;AACY;AAChB;AACU;AACD;AAED;AACG,cAAQ,YAAA;;AAKF;6CAGkD,WAAW;AAErF;AAGT,mCAAmB,gBAAgB,iBACrB,0BAA0B,qBACrB,iBAAiB,iBACrB,+BAA+B;;AAMxD;;;AASuB,4BAAoB,YAAY;AAAE;AAWzD;AAIA;AASA;AAQA;gBAWY,cAAc;;yCAxFf,WAAW;2CAAX,WAAW;AAmGvB;;ACxJD;;;;;AAKG;AACH,cAIa,eAAgB,YAAW,SAAS;;;;;;AAM5B,0BAAU,SAAS,QACb,UAAU,CAAC,WAAW,WACrC,MAAM;AAoBhB;AASA;AAIA;AAIA;yCA7CW,eAAe;2CAAf,eAAe;AAsD3B;;AChED,cAUa,wBAAwB;yCAAxB,wBAAwB;2CAAxB,wBAAwB;AAAG;;ACHxC,cAAa,uBAAuB,EAAE,IAAI;AAE1C,cAKa,iBAAiB;;yCAAjB,iBAAiB;0CAAjB,iBAAiB,UAAAA,WAAA,SAAAC,eAAA,SAAAC,wBAAA,WAAA,EAAA,CAAA,YAAA,SAAA,EAAA,CAAA,kBAAA,SAAA,EAAA,CAAA,UAAA,WAAAF,WAAA,SAAAC,eAAA,SAAAC,wBAAA,SAAA,EAAA,CAAA,UAAA;0CAAjB,iBAAiB;AAI7B;;ACHD,cAQa,eAAgB,YAAW,MAAM,EAAE,SAAS;AAoBrD;AACA;AACO,mBAAe,0BAA0B;AArBb,gBAAU,YAAA;AACD;AACP;;AAEC;AACN;AACI;AACG,cAAQ,YAAA;;;;;;;;AAYvC,yBAAS,UAAU,CAAC,WAAW,kBAChB,+BAA+B,iBAChC,0BAA0B;;AAOlD;;AAcA;;AAiBA;;AAgBA;;AAYA;;AAWA;;;;;AAwBA;AAOA;;;;;AA0BA;AAUA;AAeA;AAUA;yCA/LW,eAAe;2CAAf,eAAe;AAmM3B;;ACpND,cAAa,2BAA2B,EAAE,IAAI;AAE9C,cAKa,qBAAqB;yCAArB,qBAAqB;0CAArB,qBAAqB,UAAAC,eAAA,WAAAC,EAAA,CAAA,YAAA,SAAAC,EAAA,CAAA,kBAAA,SAAAC,EAAA,CAAA,UAAA,SAAAC,iBAAA,WAAAJ,eAAA,SAAAI,iBAAA,SAAAD,EAAA,CAAA,UAAA;0CAArB,qBAAqB;AAAG;;","names":["i1.HermesModal","i2.HermesModalBody","i3.HermesModalHostComponent","i1.HermesSidePanel","i2","i3","i4","i5.HermesModalModule"]}

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

@@ -0,0 +1,317 @@
+import { ConnectedPosition, FlexibleConnectedPositionStrategyOrigin, OverlayContainer, Overlay } from '@angular/cdk/overlay';
+import * as i0 from '@angular/core';
+import { ElementRef, OnDestroy, AfterViewInit, ViewContainerRef, TemplateRef, NgZone, OnInit, InjectionToken, EventEmitter } from '@angular/core';
+import { Observable } from 'rxjs';
+import { HermesPosition } from '@hermes-ui/angular/utils';
+
+declare enum HermesPopoverType {
+    SIGNPOST = 0,
+    TOOLTIP = 1,
+    DROPDOWN = 2,
+    DEFAULT = 3
+}
+declare enum HermesPopoverPosition {
+    TOP_RIGHT = "top-right",
+    TOP_MIDDLE = "top-middle",
+    TOP_LEFT = "top-left",
+    RIGHT = "right",
+    RIGHT_TOP = "right-top",
+    RIGHT_MIDDLE = "right-middle",
+    RIGHT_BOTTOM = "right-bottom",
+    LEFT = "left",
+    LEFT_TOP = "left-top",
+    LEFT_MIDDLE = "left-middle",
+    LEFT_BOTTOM = "left-bottom",
+    BOTTOM_RIGHT = "bottom-right",
+    BOTTOM_MIDDLE = "bottom-middle",
+    BOTTOM_LEFT = "bottom-left"
+}
+declare const TOOLTIP_POSITIONS: HermesPopoverPosition[];
+declare const DROPDOWN_POSITIONS: HermesPopoverPosition[];
+declare const SIGNPOST_POSITIONS: HermesPopoverPosition[];
+declare function getPositionsArray(type: HermesPopoverType): HermesPopoverPosition[];
+declare function getConnectedPositions(type: HermesPopoverType): ConnectedPosition[];
+declare function mapPopoverKeyToPosition(key: HermesPopoverPosition, type: HermesPopoverType): ConnectedPosition;
+declare function getOriginPosition(key: HermesPosition): Partial<ConnectedPosition>;
+declare function getContentPosition(key: HermesPosition): Partial<ConnectedPosition>;
+
+interface HermesPopoverPoint {
+    x: number;
+    y: number;
+}
+declare class HermesPopoverService {
+    pointTargetElement: HTMLElement | undefined;
+    origin: FlexibleConnectedPositionStrategyOrigin;
+    closeButtonRef: ElementRef;
+    panelClass: string[];
+    private _open;
+    private _openChange;
+    private _openEvent;
+    private _openEventChange;
+    private _positionChange;
+    private _resetPositions;
+    private _updatePosition;
+    private _popoverVisible;
+    get originElement(): ElementRef<HTMLElement> | null;
+    get originPoint(): HermesPopoverPoint | null;
+    get openChange(): Observable<boolean>;
+    get popoverVisible(): Observable<boolean>;
+    get openEvent(): Event;
+    set openEvent(event: Event);
+    get open(): boolean;
+    set open(value: boolean);
+    get resetPositionsChange(): Observable<void>;
+    positionChange(position: HermesPopoverPosition): void;
+    updatePositionChange(): Observable<void>;
+    getPositionChange(): Observable<string>;
+    getEventChange(): Observable<Event>;
+    /**
+     * Sometimes, we need to remember the event that triggered the toggling to avoid loops.
+     * This is for instance the case of components that open on a click, but close on a click outside.
+     */
+    toggleWithEvent(event: any): void;
+    /**
+     * Opens the popover at a specific screen coordinate.
+     * Useful for context menus where the popover should appear at the cursor position.
+     */
+    openAtPoint(point: HermesPopoverPoint, targetElement?: HTMLElement): void;
+    popoverVisibleEmit(visible: boolean): void;
+    resetPositions(): void;
+    updatePosition(): void;
+    focusCloseButton(): void;
+    focusOrigin(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HermesPopoverService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<HermesPopoverService>;
+}
+
+/** @dynamic */
+declare class HermesPopoverContent implements OnDestroy, AfterViewInit {
+    private container;
+    private template;
+    private parent;
+    private overlay;
+    private popoverService;
+    private zone;
+    private platformId;
+    private _outsideClickClose;
+    private _scrollToClose;
+    private view;
+    private elementRef;
+    private overlayRef;
+    private popoverType;
+    private _availablePositions;
+    private _position;
+    private subscriptions;
+    private openCloseSubscription;
+    private domPortal;
+    private preferredPositionIsSet;
+    private availablePositionsAreSet;
+    private _preferredPosition;
+    private intersectionObserver;
+    constructor(element: ElementRef, container: ViewContainerRef, template: TemplateRef<any>, overlayContainer: OverlayContainer, parent: HermesPopoverContent, overlay: Overlay, popoverService: HermesPopoverService, zone: NgZone, platformId: any);
+    set open(value: boolean);
+    get contentAt(): string | HermesPopoverPosition | ConnectedPosition;
+    set contentAt(position: string | HermesPopoverPosition | ConnectedPosition);
+    set availablePositions(positions: ConnectedPosition[]);
+    set contentType(type: HermesPopoverType);
+    get outsideClickClose(): boolean;
+    set outsideClickClose(clickToClose: boolean);
+    get scrollToClose(): boolean;
+    set scrollToClose(scrollToClose: boolean);
+    set contentOrigin(origin: FlexibleConnectedPositionStrategyOrigin);
+    private get positionStrategy();
+    private get preferredPosition();
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    private _createOverlayRef;
+    /**
+     * Point-based origins (context menus) delay the subscription to avoid the
+     * mouseup from the same right-click that opened the popover.
+     */
+    private createPointBasedOutsideClickSubscription;
+    private handlePointOutsideClick;
+    /**
+     * Mirrors createCrossWindowOutsideClickSubscription for point-based origins (context
+     * menus): pointTargetElement - the element the point was derived from, e.g. the
+     * right-clicked element - can itself live inside a foreign iframe document, and CDK's
+     * outsidePointerEvents() only listens on this window's document, so a click elsewhere
+     * in that foreign document would otherwise never dismiss the menu. Delayed by the same
+     * 500ms as the same-window stream, for the same reason: avoid the click that opened the
+     * menu immediately closing it again.
+     */
+    private createCrossWindowPointOutsideClickSubscription;
+    /**
+     * Element-based origins close on outside clicks and suppress toggle-button
+     * re-clicks so the popover doesn't immediately reopen.
+     */
+    private createElementBasedOutsideClickSubscription;
+    private handleOutsideClick;
+    /**
+     * CDK's outsidePointerEvents() only listens on the document that owns the overlay
+     * (this window's), so clicks inside a cross-window origin's own document (e.g. a
+     * ShadowRoot hosted in an iframe) are invisible to it - see resolveCrossWindowOrigin
+     * for the same cross-window scenario affecting positioning instead. Any pointer event
+     * dispatched in that foreign document is guaranteed to be outside the overlay panel,
+     * since the panel always renders in this window's document, so this only needs the
+     * toggle-button exclusion handleOutsideClick already does, not the content-panel
+     * containment check (which can never be true across documents).
+     *
+     * Listens on capture-phase click/auxclick, mirroring CDK's own OverlayOutsideClickDispatcher.
+     * Capture phase matters: for a toggle re-click, this listener must run and
+     * stopPropagation() BEFORE the trigger's own bubble-phase click handler
+     * (HermesDropdownTrigger's toggleWithEvent) gets a chance to fire, otherwise the popover
+     * closes here and immediately reopens there. A bubble-phase or pointerdown-based
+     * listener can't suppress that handler at all, since pointerdown and click are separate
+     * events and stopping one doesn't affect the other.
+     *
+     * The foreign document's own addEventListener isn't zone-patched (zone.js only patches
+     * the window it's loaded into), so the listener is registered directly and the handler
+     * is explicitly run back inside NgZone.
+     */
+    private createCrossWindowOutsideClickSubscription;
+    /**
+     * CDK's OverlayKeyboardDispatcher (the source behind `overlayRef.keydownEvents()`)
+     * attaches a single keydown listener on this window's document.body once, at app
+     * bootstrap - see its `add()`/`_keydownListener`. A keydown fired while focus sits
+     * inside a cross-window origin's own document (e.g. a ShadowRoot hosted in an iframe)
+     * never bubbles there, since events don't cross document boundaries, so Escape silently
+     * does nothing once the trigger (and focus) has moved into that foreign document. This
+     * mirrors createCrossWindowOutsideClickSubscription's rationale for outside clicks -
+     * merged into a single stream/handler here since both ultimately just detect Escape and
+     * close.
+     */
+    private createEscapeSubscription;
+    private resetPosition;
+    private closePopover;
+    private showOverlay;
+    private removeOverlay;
+    /**
+     * Walks ancestors looking for scrollable containers, following the node up through
+     * ShadowRoots and, when the node's own ancestry crosses into an iframe (a different
+     * window realm - e.g. a ShadowRoot hosted in a micro-frontend iframe), continuing the
+     * walk into the parent window via window.frameElement, all the way up to the true
+     * top-level document. Every embedded document passed through this way is added as its
+     * own scrollable parent, so page-level scrolling inside an iframe is tracked too.
+     *
+     * `instanceof` checks are realm-sensitive (they fail for nodes created by a different
+     * window's constructors), so this deliberately uses realm-independent shape checks
+     * (nodeType, tagName, duck-typing ShadowRoot via `host`) instead, and always resolves
+     * computed style through the node's own window rather than this one. This is what lets
+     * the walk safely continue across a same-origin realm boundary instead of just
+     * stopping at it.
+     */
+    private getScrollableParents;
+    /**
+     * Uses IntersectionObserver to detect when the origin element leaves the screen.
+     * This handles the "Close on Scroll" logic much cheaper than getBoundingClientRect.
+     */
+    private setupIntersectionObserver;
+    private listenToScrollEvents;
+    private listenToScrollForElementOrigin;
+    private getRootPopover;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HermesPopoverContent, [null, null, { optional: true; }, null, { optional: true; skipSelf: true; }, null, null, null, null]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HermesPopoverContent, "[hermesPopoverContent]", never, { "open": { "alias": "hermesPopoverContent"; "required": false; }; "contentAt": { "alias": "hermesPopoverContentAt"; "required": false; }; "availablePositions": { "alias": "hermesPopoverContentAvailablePositions"; "required": false; }; "contentType": { "alias": "hermesPopoverContentType"; "required": false; }; "outsideClickClose": { "alias": "hermesPopoverContentOutsideClickToClose"; "required": false; }; "scrollToClose": { "alias": "hermesPopoverContentScrollToClose"; "required": false; }; "contentOrigin": { "alias": "hermesPopoverContentOrigin"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class HermesPopoverOrigin {
+    constructor(popoverService: HermesPopoverService, element: ElementRef<HTMLButtonElement>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<HermesPopoverOrigin, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HermesPopoverOrigin, "[hermesPopoverOrigin]", never, {}, {}, never, never, false, never>;
+}
+
+declare class HermesStopEscapePropagationDirective implements OnInit, OnDestroy {
+    private popoverService;
+    private subscription;
+    private lastOpenChange;
+    constructor(popoverService: HermesPopoverService);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    onEscapeKey(event: KeyboardEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HermesStopEscapePropagationDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HermesStopEscapePropagationDirective, never, never, {}, {}, never, never, true, never>;
+}
+
+declare class HermesPopoverHostDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<HermesPopoverHostDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HermesPopoverHostDirective, never, never, {}, {}, never, never, true, [{ directive: typeof HermesStopEscapePropagationDirective; inputs: {}; outputs: {}; }]>;
+}
+
+declare const POPOVER_HOST_ORIGIN: InjectionToken<ElementRef<any>>;
+
+/**********
+ *
+ * @class HermesIfOpen
+ *
+ * @description
+ * A structural directive that controls whether or not the associated TemplateRef is instantiated or not.
+ * It makes use of a Component instance level service: HermesPopoverService to maintain state between itself and the component
+ * using it in the component template.
+ *
+ */
+declare class HermesIfOpen implements OnDestroy {
+    private popoverService;
+    private template;
+    private container;
+    static ngAcceptInputType_open: boolean | '';
+    /**********
+     * @property openChange
+     *
+     * @description
+     * An event emitter that emits when the open property is set to allow for 2way binding when the directive is
+     * used with de-structured / de-sugared syntax.
+     */
+    openChange: EventEmitter<boolean>;
+    private subscriptions;
+    constructor(popoverService: HermesPopoverService, template: TemplateRef<any>, container: ViewContainerRef);
+    /**
+     * @description
+     * A property that gets/sets HermesPopoverService.open with value.
+     */
+    get open(): boolean | string;
+    set open(value: boolean | string);
+    ngOnDestroy(): void;
+    /**
+     * @description
+     * Function that takes a boolean value and either created an embedded view for the associated ViewContainerRef or,
+     * Clears all views from the ViewContainerRef
+     *
+     * @param value
+     */
+    updateView(value: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HermesIfOpen, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HermesIfOpen, "[hermesIfOpen]", never, { "open": { "alias": "hermesIfOpen"; "required": false; }; }, { "openChange": "hermesIfOpenChange"; }, never, never, true, never>;
+}
+
+declare class HermesPopoverCloseButton implements OnDestroy, AfterViewInit {
+    private elementRef;
+    private popoverService;
+    closeChange: EventEmitter<void>;
+    private subscriptions;
+    constructor(elementRef: ElementRef<HTMLButtonElement>, popoverService: HermesPopoverService);
+    handleClick(event: MouseEvent): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HermesPopoverCloseButton, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HermesPopoverCloseButton, "[hermesPopoverCloseButton]", never, {}, { "closeChange": "hermesPopoverOnCloseChange"; }, never, never, false, never>;
+}
+
+declare class HermesPopoverOpenCloseButton implements OnDestroy {
+    private popoverService;
+    openCloseChange: EventEmitter<boolean>;
+    private subscriptions;
+    constructor(popoverService: HermesPopoverService);
+    handleClick(event: MouseEvent): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HermesPopoverOpenCloseButton, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HermesPopoverOpenCloseButton, "[hermesPopoverOpenCloseButton]", never, {}, { "openCloseChange": "hermesPopoverOpenCloseChange"; }, never, never, false, never>;
+}
+
+declare class HermesPopoverModuleNext {
+    static ɵfac: i0.ɵɵFactoryDeclaration<HermesPopoverModuleNext, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<HermesPopoverModuleNext, [typeof HermesPopoverOrigin, typeof HermesPopoverCloseButton, typeof HermesPopoverOpenCloseButton], [typeof HermesPopoverContent, typeof HermesIfOpen], [typeof HermesPopoverOrigin, typeof HermesPopoverCloseButton, typeof HermesPopoverOpenCloseButton, typeof HermesPopoverContent, typeof HermesIfOpen]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<HermesPopoverModuleNext>;
+}
+
+export { DROPDOWN_POSITIONS, HermesIfOpen, HermesPopoverCloseButton, HermesPopoverContent, HermesPopoverHostDirective, HermesPopoverModuleNext, HermesPopoverOpenCloseButton, HermesPopoverOrigin, HermesPopoverPosition, HermesPopoverService, HermesPopoverType, HermesStopEscapePropagationDirective, POPOVER_HOST_ORIGIN, SIGNPOST_POSITIONS, TOOLTIP_POSITIONS, getConnectedPositions, getContentPosition, getOriginPosition, getPositionsArray, mapPopoverKeyToPosition };
+export type { HermesPopoverPoint };
+//# sourceMappingURL=hermes-ui-angular-popover-common.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"hermes-ui-angular-popover-common.d.ts","sources":["../../../popover/common/utils/popover-positions.ts","../../../popover/common/providers/popover.service.ts","../../../popover/common/popover-content.ts","../../../popover/common/popover-origin.ts","../../../popover/common/stop-escape-propagation.directive.ts","../../../popover/common/popover-host.directive.ts","../../../popover/common/popover-host-origin.token.ts","../../../popover/common/if-open.directive.ts","../../../popover/common/popover-close-button.ts","../../../popover/common/popover-open-close-button.ts","../../../popover/common/popover.module.ts"],"mappings":"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","names":["i1.HermesStopEscapePropagationDirective","i1.HermesPopoverOrigin","i2.HermesPopoverCloseButton","i3.HermesPopoverOpenCloseButton","i4.HermesPopoverContent","i5.HermesIfOpen"]}