primeng 16.0.0-rc.1 → 16.0.0-rc.2

package/organizationchart/organizationchart.interface.d.ts

@@ -0,0 +1,54 @@
+import { TemplateRef } from '@angular/core';
+import { TreeNode } from 'primeng/api';
+/**
+ * Custom node select event.
+ * @see {@link OrganizationChart.onNodeSelect}
+ */
+export interface OrganizationChartNodeSelectEvent {
+    /**
+     * Browser event.
+     */
+    originalEvent: Event;
+    /**
+     * Node instance.
+     */
+    node: TreeNode;
+}
+/**
+ * Custom node unselect event.
+ * @see {@link OrganizationChart.onNodeUnSelect}
+ */
+export interface OrganizationChartNodeUnSelectEvent extends OrganizationChartNodeSelectEvent {
+}
+/**
+ * Custom node expand event.
+ * @see {@link OrganizationChart.onNodeExpand}
+ * @extends {OrganizationChartNodeSelectEvent}
+ */
+export interface OrganizationChartNodeExpandEvent extends OrganizationChartNodeSelectEvent {
+}
+/**
+ * Custom node collapse event.
+ * @see {@link OrganizationChart.onNodeCollapse}
+ * @extends {OrganizationChartNodeSelectEvent}
+ */
+export interface OrganizationChartNodeCollapseEvent extends OrganizationChartNodeSelectEvent {
+}
+/**
+ * Defines valid templates in OrganizationChart.
+ * @group Templates
+ */
+export interface OrganizationChartTemplates {
+    /**
+     * Custom toggler icon template.
+     * @param {Object} context - item data.
+     */
+    togglericon(context: {
+        /**
+         * Expanded state of the node.
+         */
+        $implicit: boolean;
+    }): TemplateRef<{
+        $implicit: boolean;
+    }>;
+}

package/organizationchart/public_api.d.ts

@@ -1 +1,2 @@
 export * from './organizationchart';
+export * from './organizationchart.interface';

package/overlay/overlay.d.ts

@@ -1,6 +1,6 @@
 import { AnimationEvent } from '@angular/animations';
 import { AfterContentInit, ElementRef, EventEmitter, NgZone, OnDestroy, QueryList, Renderer2, TemplateRef } from '@angular/core';
-import { OverlayModeType, OverlayOptions, OverlayService, PrimeNGConfig, ResponsiveOverlayOptions } from 'primeng/api';
+import { OverlayModeType, OverlayOnBeforeHideEvent, OverlayOnBeforeShowEvent, OverlayOnHideEvent, OverlayOnShowEvent, OverlayOptions, OverlayService, PrimeNGConfig, ResponsiveOverlayOptions } from 'primeng/api';
 import * as i0 from "@angular/core";
 import * as i1 from "@angular/common";
 import * as i2 from "primeng/api";
@@ -13,43 +13,138 @@ export declare class Overlay implements AfterContentInit, OnDestroy {
     private config;
     overlayService: OverlayService;
     private zone;
+    /**
+     * The visible property is an input that determines the visibility of the component.
+     * @group Props
+     */
     get visible(): boolean;
     set visible(value: boolean);
+    /**
+     * The mode property is an input that determines the overlay mode type or string.
+     * @group Props
+     */
     get mode(): OverlayModeType | string;
     set mode(value: OverlayModeType | string);
+    /**
+     * The style property is an input that determines the style object for the component.
+     * @group Props
+     */
     get style(): any;
     set style(value: any);
+    /**
+     * The styleClass property is an input that determines the CSS class(es) for the component.
+     * @group Props
+     */
     get styleClass(): string;
     set styleClass(value: string);
+    /**
+     * The contentStyle property is an input that determines the style object for the content of the component.
+     * @group Props
+     */
     get contentStyle(): any;
     set contentStyle(value: any);
+    /**
+     * The contentStyleClass property is an input that determines the CSS class(es) for the content of the component.
+     * @group Props
+     */
     get contentStyleClass(): string;
     set contentStyleClass(value: string);
+    /**
+     * The target property is an input that specifies the target element or selector for the component.
+     * @group Props
+     */
     get target(): any;
     set target(value: any);
+    /**
+     * Overlay can be mounted into its location, body or DOM element instance using this option.
+     * @group Props
+     */
     get appendTo(): any;
     set appendTo(value: any);
+    /**
+     * The autoZIndex determines whether to automatically manage layering. Its default value is 'false'.
+     * @group Props
+     */
     get autoZIndex(): boolean;
     set autoZIndex(value: boolean);
+    /**
+     * The baseZIndex is base zIndex value to use in layering. Its default value is 0.
+     * @group Props
+     */
     get baseZIndex(): number;
     set baseZIndex(value: number);
+    /**
+     * Transition options of the show or hide animation. The default value of showTransitionOptions is '.12s cubic-bezier(0, 0, 0.2, 1)' and the default value of hideTransitionOptions is '.1s linear'.
+     * @group Props
+     */
     get showTransitionOptions(): string;
     set showTransitionOptions(value: string);
+    /**
+     * The hideTransitionOptions property is an input that determines the CSS transition options for hiding the component.
+     * @group Props
+     */
     get hideTransitionOptions(): string;
     set hideTransitionOptions(value: string);
+    /**
+     * The listener property is an input that specifies the listener object for the component.
+     * @group Props
+     */
     get listener(): any;
     set listener(value: any);
+    /**
+     * It is the option used to determine in which mode it should appear according to the given media or breakpoint.
+     * @group Props
+     */
     get responsive(): ResponsiveOverlayOptions | undefined;
     set responsive(val: ResponsiveOverlayOptions | undefined);
+    /**
+     * The options property is an input that specifies the overlay options for the component.
+     * @group Props
+     */
     get options(): OverlayOptions | undefined;
     set options(val: OverlayOptions | undefined);
-    visibleChange: EventEmitter<any>;
-    onBeforeShow: EventEmitter<any>;
-    onShow: EventEmitter<any>;
-    onBeforeHide: EventEmitter<any>;
-    onHide: EventEmitter<any>;
-    onAnimationStart: EventEmitter<any>;
-    onAnimationDone: EventEmitter<any>;
+    /**
+     * This EventEmitter is used to notify changes in the visibility state of a component.
+     * @param {Boolean} boolean - Value of visibility as boolean.
+     * @group Emits
+     */
+    visibleChange: EventEmitter<boolean>;
+    /**
+     * Callback to invoke before the overlay is shown.
+     * @param {OverlayOnBeforeShowEvent} event - Custom overlay before show event.
+     * @group Emits
+     */
+    onBeforeShow: EventEmitter<OverlayOnBeforeShowEvent>;
+    /**
+     * Callback to invoke when the overlay is shown.
+     * @param {OverlayOnShowEvent} event - Custom overlay show event.
+     * @group Emits
+     */
+    onShow: EventEmitter<OverlayOnShowEvent>;
+    /**
+     * Callback to invoke before the overlay is hidden.
+     * @param {OverlayOnBeforeHideEvent} event - Custom overlay before hide event.
+     * @group Emits
+     */
+    onBeforeHide: EventEmitter<OverlayOnBeforeHideEvent>;
+    /**
+     * Callback to invoke when the overlay is hidden
+     * @param {OverlayOnHideEvent} event - Custom hide event.
+     * @group Emits
+     */
+    onHide: EventEmitter<OverlayOnHideEvent>;
+    /**
+     * Callback to invoke when the animation is started.
+     * @param {AnimationEvent} event - Animation event.
+     * @group Emits
+     */
+    onAnimationStart: EventEmitter<AnimationEvent>;
+    /**
+     * Callback to invoke when the animation is done.
+     * @param {AnimationEvent} event - Animation event.
+     * @group Emits
+     */
+    onAnimationDone: EventEmitter<AnimationEvent>;
     templates: QueryList<any> | undefined;
     overlayViewChild: ElementRef | undefined;
     contentViewChild: ElementRef | undefined;
@@ -92,7 +187,7 @@ export declare class Overlay implements AfterContentInit, OnDestroy {
     hide(overlay?: HTMLElement, isFocus?: boolean): void;
     alignOverlay(): void;
     onVisibleChange(visible: boolean): void;
-    onOverlayClick(event: any): void;
+    onOverlayClick(): void;
     onOverlayContentClick(event: MouseEvent): void;
     onOverlayContentAnimationStart(event: AnimationEvent): void;
     onOverlayContentAnimationDone(event: AnimationEvent): void;

package/overlaypanel/overlaypanel.d.ts

@@ -1,8 +1,9 @@
 import { AnimationEvent } from '@angular/animations';
 import { AfterContentInit, ChangeDetectorRef, ElementRef, EventEmitter, NgZone, OnDestroy, QueryList, Renderer2, TemplateRef } from '@angular/core';
-import { OverlayService, PrimeNGConfig } from 'primeng/api';
+import { OverlayService, PrimeNGConfig, PrimeTemplate } from 'primeng/api';
 import { ConnectedOverlayScrollHandler } from 'primeng/dom';
 import { Subscription } from 'rxjs';
+import { Nullable, VoidListener } from 'primeng/ts-helpers';
 import * as i0 from "@angular/core";
 import * as i1 from "@angular/common";
 import * as i2 from "primeng/ripple";
@@ -17,42 +18,108 @@ export declare class OverlayPanel implements AfterContentInit, OnDestroy {
     private zone;
     config: PrimeNGConfig;
     overlayService: OverlayService;
+    /**
+     * Enables to hide the overlay when outside is clicked.
+     * @group Props
+     */
     dismissable: boolean;
-    showCloseIcon: boolean;
-    style: any;
-    styleClass: string;
+    /**
+     * When enabled, displays a close icon at top right corner.
+     * @group Props
+     */
+    showCloseIcon: boolean | undefined;
+    /**
+     * Inline style of the component.
+     * @group Props
+     */
+    style: {
+        [klass: string]: any;
+    } | null | undefined;
+    /**
+     * Style class of the component.
+     * @group Props
+     */
+    styleClass: string | undefined;
+    /**
+     *  Target element to attach the panel, valid values are "body" or a local ng-template variable of another element (note: use binding with brackets for template variables, e.g. [appendTo]="mydiv" for a div element having #mydiv as variable name).
+     * @group Props
+     */
     appendTo: any;
+    /**
+     * Whether to automatically manage layering.
+     * @group Props
+     */
     autoZIndex: boolean;
-    ariaCloseLabel: string;
+    /**
+     * Aria label of the close icon.
+     * @group Props
+     */
+    ariaCloseLabel: string | undefined;
+    /**
+     * Base zIndex value to use in layering.
+     * @group Props
+     */
     baseZIndex: number;
+    /**
+     * When enabled, first button receives focus on show.
+     * @group Props
+     */
     focusOnShow: boolean;
+    /**
+     * Transition options of the show animation.
+     * @group Props
+     */
     showTransitionOptions: string;
+    /**
+     * Transition options of the hide animation.
+     * @group Props
+     */
     hideTransitionOptions: string;
+    /**
+     * Callback to invoke when an overlay becomes visible.
+     * @group Emits
+     */
     onShow: EventEmitter<any>;
-    onHide: EventEmitter<any>;
-    templates: QueryList<any>;
-    container: HTMLDivElement;
+    /**
+     * Callback to invoke when an overlay gets hidden.
+     * @group Emits
+     */
+    onHide: EventEmitter<object>;
+    templates: QueryList<PrimeTemplate> | undefined;
+    container: Nullable<HTMLDivElement>;
     overlayVisible: boolean;
     render: boolean;
     isOverlayAnimationInProgress: boolean;
     selfClick: boolean;
-    documentClickListener: () => void | null;
+    documentClickListener: VoidListener;
     target: any;
-    willHide: boolean;
-    scrollHandler: ConnectedOverlayScrollHandler | null;
-    documentResizeListener: () => void | null;
-    contentTemplate: TemplateRef<any>;
-    closeIconTemplate: TemplateRef<any>;
-    destroyCallback: Function;
-    overlayEventListener: (event?: any) => void | null;
-    overlaySubscription: Subscription;
+    willHide: Nullable<boolean>;
+    scrollHandler: Nullable<ConnectedOverlayScrollHandler>;
+    documentResizeListener: VoidListener;
+    contentTemplate: Nullable<TemplateRef<any>>;
+    closeIconTemplate: Nullable<TemplateRef<any>>;
+    destroyCallback: Nullable<Function>;
+    overlayEventListener: Nullable<(event?: any) => void>;
+    overlaySubscription: Subscription | undefined;
     constructor(document: Document, platformId: any, el: ElementRef, renderer: Renderer2, cd: ChangeDetectorRef, zone: NgZone, config: PrimeNGConfig, overlayService: OverlayService);
     ngAfterContentInit(): void;
     bindDocumentClickListener(): void;
     unbindDocumentClickListener(): void;
+    /**
+     * Toggles the visibility of the panel.
+     * @param event - Browser event
+     * @param target - Target element.
+     * @group Methods
+     */
     toggle(event: any, target?: any): void;
+    /**
+     * Displays the panel.
+     * @param event
+     * @param target
+     * @group Methods
+     */
     show(event: any, target?: any): void;
-    onOverlayClick(event: any): void;
+    onOverlayClick(event: MouseEvent): void;
     onContentClick(): void;
     hasTargetChanged(event: any, target: any): boolean;
     appendContainer(): void;
@@ -61,9 +128,13 @@ export declare class OverlayPanel implements AfterContentInit, OnDestroy {
     onAnimationStart(event: AnimationEvent): void;
     onAnimationEnd(event: AnimationEvent): void;
     focus(): void;
+    /**
+     * Hides the panel.
+     * @group Methods
+     */
     hide(): void;
-    onCloseClick(event: any): void;
-    onWindowResize(event: any): void;
+    onCloseClick(event: MouseEvent): void;
+    onWindowResize(): void;
     bindDocumentResizeListener(): void;
     unbindDocumentResizeListener(): void;
     bindScrollListener(): void;