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

package/accordion/accordion.d.ts

@@ -1,6 +1,7 @@
 import { AfterContentInit, ChangeDetectorRef, ElementRef, EventEmitter, OnDestroy, QueryList, TemplateRef } from '@angular/core';
-import { BlockableUI, Header } from 'primeng/api';
+import { BlockableUI, Header, PrimeTemplate } from 'primeng/api';
 import { Subscription } from 'rxjs';
+import { AccordionTabCloseEvent, AccordionTabOpenEvent } from './accordion.interface';
 import * as i0 from "@angular/core";
 import * as i1 from "@angular/common";
 import * as i2 from "primeng/icons/chevronright";
@@ -8,33 +9,91 @@ import * as i3 from "primeng/icons/chevrondown";
 import * as i4 from "primeng/api";
 export declare class AccordionTab implements AfterContentInit, OnDestroy {
     changeDetector: ChangeDetectorRef;
-    header: string;
-    headerStyle: any;
-    tabStyle: any;
-    contentStyle: any;
-    tabStyleClass: string;
-    headerStyleClass: string;
-    contentStyleClass: string;
-    disabled: boolean;
+    /**
+     * Used to define the header of the tab.
+     * @group Props
+     */
+    header: string | undefined;
+    /**
+     * Inline style of the tab header.
+     * @group Props
+     */
+    headerStyle: {
+        [klass: string]: any;
+    } | null | undefined;
+    /**
+     * Inline style of the tab.
+     * @group Props
+     */
+    tabStyle: {
+        [klass: string]: any;
+    } | null | undefined;
+    /**
+     * Inline style of the tab content.
+     * @group Props
+     */
+    contentStyle: {
+        [klass: string]: any;
+    } | null | undefined;
+    /**
+     * Style class of the tab.
+     * @group Props
+     */
+    tabStyleClass: string | undefined;
+    /**
+     * Style class of the tab header.
+     * @group Props
+     */
+    headerStyleClass: string | undefined;
+    /**
+     * Style class of the tab content.
+     * @group Props
+     */
+    contentStyleClass: string | undefined;
+    /**
+     * Whether the tab is disabled.
+     * @group Props
+     */
+    disabled: boolean | undefined;
+    /**
+     * Whether a lazy loaded panel should avoid getting loaded again on reselection.
+     * @group Props
+     */
     cache: boolean;
-    selectedChange: EventEmitter<any>;
+    /**
+     * Transition options of the animation.
+     * @group Props
+     */
     transitionOptions: string;
+    /**
+     * Position of the icon, valid values are "end", "start".
+     * @group Props
+     */
     iconPos: string;
+    /**
+     * Event triggered by changing the choice
+     * @group Emits
+     */
+    selectedChange: EventEmitter<boolean>;
     headerFacet: QueryList<Header>;
-    templates: QueryList<any>;
+    templates: QueryList<PrimeTemplate>;
     private _selected;
-    get selected(): any;
-    set selected(val: any);
+    /**
+     * The value that returns the selection.
+     * @group Props
+     */
+    get selected(): boolean;
+    set selected(val: boolean);
     get iconClass(): "p-accordion-toggle-icon-end" | "p-accordion-toggle-icon";
-    contentTemplate: TemplateRef<any>;
-    headerTemplate: TemplateRef<any>;
+    contentTemplate: TemplateRef<any> | undefined;
+    headerTemplate: TemplateRef<any> | undefined;
+    iconTemplate: TemplateRef<any> | undefined;
     id: string;
     loaded: boolean;
-    iconTemplate: TemplateRef<any>;
     accordion: Accordion;
-    constructor(accordion: any, changeDetector: ChangeDetectorRef);
+    constructor(accordion: Accordion, changeDetector: ChangeDetectorRef);
     ngAfterContentInit(): void;
-    toggle(event: any): boolean;
+    toggle(event: MouseEvent | KeyboardEvent): boolean;
     findTabIndex(): number;
     get hasHeaderFacet(): boolean;
     onKeydown(event: KeyboardEvent): void;
@@ -45,25 +104,63 @@ export declare class AccordionTab implements AfterContentInit, OnDestroy {
 export declare class Accordion implements BlockableUI, AfterContentInit, OnDestroy {
     el: ElementRef;
     changeDetector: ChangeDetectorRef;
+    /**
+     * When enabled, multiple tabs can be activated at the same time.
+     * @group Props
+     */
     multiple: boolean;
-    onClose: EventEmitter<any>;
-    onOpen: EventEmitter<any>;
-    style: any;
-    styleClass: string;
-    expandIcon: string;
-    collapseIcon: string;
-    activeIndexChange: EventEmitter<any>;
-    tabList: QueryList<AccordionTab>;
-    tabListSubscription: Subscription;
+    /**
+     * Inline style of the tab header and content.
+     * @group Props
+     */
+    style: {
+        [klass: string]: any;
+    } | null | undefined;
+    /**
+     * Class of the element.
+     * @group Props
+     */
+    styleClass: string | undefined;
+    /**
+     * Icon of a collapsed tab.
+     * @group Props
+     */
+    expandIcon: string | undefined;
+    /**
+     * Icon of an expanded tab.
+     * @group Props
+     */
+    collapseIcon: string | undefined;
+    /**
+     * Index of the active tab or an array of indexes in multiple mode.
+     * @group Props
+     */
+    get activeIndex(): number | number[] | null | undefined;
+    set activeIndex(val: number | number[] | null | undefined);
+    /**
+     * Callback to invoke when an active tab is collapsed by clicking on the header.
+     * @group Emits
+     */
+    onClose: EventEmitter<AccordionTabCloseEvent>;
+    /**
+     * Callback to invoke when a tab gets expanded.
+     * @group Emits
+     */
+    onOpen: EventEmitter<AccordionTabOpenEvent>;
+    /**
+     * Returns the active index.
+     * @group Emits
+     */
+    activeIndexChange: EventEmitter<number | number[] | null>;
+    tabList: QueryList<AccordionTab> | undefined;
+    tabListSubscription: Subscription | null;
     private _activeIndex;
     preventActiveIndexPropagation: boolean;
     tabs: AccordionTab[];
     constructor(el: ElementRef, changeDetector: ChangeDetectorRef);
     ngAfterContentInit(): void;
-    initTabs(): any;
+    initTabs(): void;
     getBlockableElement(): HTMLElement;
-    get activeIndex(): any;
-    set activeIndex(val: any);
     updateSelectionState(): void;
     updateActiveIndex(): void;
     ngOnDestroy(): void;

package/accordion/accordion.interface.d.ts

@@ -0,0 +1,47 @@
+import { TemplateRef } from '@angular/core';
+/**
+ * Custom tab open event.
+ * @see {@link Accordion.onOpen}
+ */
+export interface AccordionTabOpenEvent {
+    /**
+     * Browser event.
+     */
+    originalEvent: Event;
+    /**
+     * Opened tab index.
+     */
+    index: number;
+}
+/**
+ * Custom tab close event.
+ * @see {@link Accordion.onClose}
+ * @extends {AccordionTabOpenEvent}
+ */
+export interface AccordionTabCloseEvent extends AccordionTabOpenEvent {
+}
+/**
+ * Defines valid templates in Accordion.
+ * @group Templates
+ */
+export interface AccordionTemplates {
+    /**
+     * Custom template of content.
+     */
+    content: TemplateRef<any> | null;
+    /**
+     * Custom template of header.
+     */
+    header: TemplateRef<any> | null;
+    /**
+     * Custom template of icon.
+     */
+    icon(context: {
+        /**
+         * Data of the selected.
+         */
+        $implicit: any;
+    }): TemplateRef<{
+        $implicit: any;
+    }>;
+}

package/accordion/public_api.d.ts

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

package/animate/animate.d.ts

@@ -5,9 +5,15 @@ export declare class Animate implements AfterViewInit {
     private host;
     el: ElementRef;
     renderer: Renderer2;
-    enterClass: string;
-    leaveClass: string;
-    observer: IntersectionObserver;
+    /**
+     * Selector to define the CSS class for enter animation.
+     */
+    enterClass: string | undefined;
+    /**
+     * Selector to define the CSS class for leave animation.
+     */
+    leaveClass: string | undefined;
+    observer: IntersectionObserver | undefined;
     timeout: any;
     constructor(host: ElementRef, el: ElementRef, renderer: Renderer2);
     ngAfterViewInit(): void;

package/api/blockableui.d.ts

@@ -1,3 +1,10 @@
+/**
+ * Represents a blockable user interface element.
+ */
 export interface BlockableUI {
+    /**
+     * Retrieves the blockable element associated with the UI.
+     * @returns The HTML element that can be blocked.
+     */
     getBlockableElement(): HTMLElement;
 }

package/api/confirmation.d.ts

@@ -1,24 +1,90 @@
 import { EventEmitter } from '@angular/core';
+/**
+ * Represents a confirmation dialog configuration.
+ */
 export interface Confirmation {
+    /**
+     * The message to be displayed in the confirmation dialog.
+     */
     message?: string;
+    /**
+     * A unique key to identify the confirmation dialog.
+     */
     key?: string;
+    /**
+     * The name of the icon to be displayed in the confirmation dialog.
+     */
     icon?: string;
+    /**
+     * The header text of the confirmation dialog.
+     */
     header?: string;
+    /**
+     * The callback function to be executed when the accept button is clicked.
+     */
     accept?: Function;
+    /**
+     * The callback function to be executed when the reject button is clicked.
+     */
     reject?: Function;
+    /**
+     * The label text for the accept button.
+     */
     acceptLabel?: string;
+    /**
+     * The label text for the reject button.
+     */
     rejectLabel?: string;
+    /**
+     * The name of the icon to be displayed on the accept button.
+     */
     acceptIcon?: string;
+    /**
+     * The name of the icon to be displayed on the reject button.
+     */
     rejectIcon?: string;
+    /**
+     * Specifies whether the accept button should be visible.
+     */
     acceptVisible?: boolean;
+    /**
+     * Specifies whether the reject button should be visible.
+     */
     rejectVisible?: boolean;
+    /**
+     * Specifies whether to block scrolling on the page when the confirmation dialog is displayed.
+     */
     blockScroll?: boolean;
+    /**
+     * Specifies whether the confirmation dialog should be closed when the escape key is pressed.
+     */
     closeOnEscape?: boolean;
+    /**
+     * Specifies whether clicking outside the confirmation dialog should dismiss it.
+     */
     dismissableMask?: boolean;
+    /**
+     * The ID or class name of the element to receive focus by default when the confirmation dialog is opened.
+     */
     defaultFocus?: string;
+    /**
+     * The CSS class name to be applied to the accept button.
+     */
     acceptButtonStyleClass?: string;
+    /**
+     * The CSS class name to be applied to the reject button.
+     */
     rejectButtonStyleClass?: string;
+    /**
+     * The target event where the confirmation dialog is triggered from.
+     */
     target?: EventTarget;
+    /**
+     * An event emitter for the accept event.
+     */
     acceptEvent?: EventEmitter<any>;
+    /**
+     * An event emitter for the reject event.
+     */
     rejectEvent?: EventEmitter<any>;
 }

package/api/contextmenuservice.d.ts

@@ -1,9 +1,10 @@
+import { Nullable } from 'primeng/ts-helpers';
 import * as i0 from "@angular/core";
 export declare class ContextMenuService {
     private activeItemKeyChange;
     activeItemKeyChange$: import("rxjs").Observable<string>;
-    activeItemKey: string;
-    changeKey(key: any): void;
+    activeItemKey: Nullable<string>;
+    changeKey(key: string): void;
     reset(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<ContextMenuService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<ContextMenuService>;

package/api/filtermetadata.d.ts

@@ -1,5 +1,17 @@
+/**
+ * Represents metadata for filtering a data set.
+ */
 export interface FilterMetadata {
+    /**
+     * The value used for filtering.
+     */
     value?: any;
+    /**
+     * The match mode for filtering.
+     */
     matchMode?: string;
+    /**
+     * The operator for filtering.
+     */
     operator?: string;
 }

package/api/filterservice.d.ts

@@ -2,26 +2,7 @@ import * as i0 from "@angular/core";
 export declare class FilterService {
     filter(value: any[], fields: any[], filterValue: any, filterMatchMode: string, filterLocale?: string): any[];
     filters: {
-        startsWith: (value: any, filter: any, filterLocale?: any) => boolean;
-        contains: (value: any, filter: any, filterLocale?: any) => boolean;
-        notContains: (value: any, filter: any, filterLocale?: any) => boolean;
-        endsWith: (value: any, filter: any, filterLocale?: any) => boolean;
-        equals: (value: any, filter: any, filterLocale?: any) => boolean;
-        notEquals: (value: any, filter: any, filterLocale?: any) => boolean;
-        in: (value: any, filter: any[]) => boolean;
-        between: (value: any, filter: any[]) => boolean;
-        lt: (value: any, filter: any, filterLocale?: any) => boolean;
-        lte: (value: any, filter: any, filterLocale?: any) => boolean;
-        gt: (value: any, filter: any, filterLocale?: any) => boolean;
-        gte: (value: any, filter: any, filterLocale?: any) => boolean;
-        is: (value: any, filter: any, filterLocale?: any) => boolean;
-        isNot: (value: any, filter: any, filterLocale?: any) => boolean;
-        before: (value: any, filter: any, filterLocale?: any) => boolean;
-        after: (value: any, filter: any, filterLocale?: any) => boolean;
-        dateIs: (value: any, filter: any) => boolean;
-        dateIsNot: (value: any, filter: any) => boolean;
-        dateBefore: (value: any, filter: any) => boolean;
-        dateAfter: (value: any, filter: any) => boolean;
+        [rule: string]: Function;
     };
     register(rule: string, fn: Function): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<FilterService, never>;

package/api/lazyloadevent.d.ts

@@ -1,15 +1,46 @@
-import { SortMeta } from './sortmeta';
 import { FilterMetadata } from './filtermetadata';
+import { SortMeta } from './sortmeta';
+/**
+ * Represents an event object for lazy loading data.
+ */
 export interface LazyLoadEvent {
+    /**
+     * The index of the first record to be loaded.
+     */
     first?: number;
+    /**
+     * The index of the last record to be loaded.
+     */
     last?: number;
+    /**
+     * The number of rows to load.
+     */
     rows?: number;
+    /**
+     * The field to be used for sorting.
+     */
     sortField?: string;
+    /**
+     * The sort order for the field.
+     */
     sortOrder?: number;
+    /**
+     * An array of sort metadata objects for multiple column sorting.
+     */
     multiSortMeta?: SortMeta[];
+    /**
+     * An object containing filter metadata for filtering the data.
+     * The keys represent the field names, and the values represent the corresponding filter metadata.
+     */
     filters?: {
         [s: string]: FilterMetadata;
     };
+    /**
+     * The global filter value for filtering across all columns.
+     */
     globalFilter?: any;
+    /**
+     * A function that can be called to force an update in the lazy loaded data.
+     */
     forceUpdate?: () => void;
 }

package/api/lazyloadmeta.d.ts

@@ -0,0 +1,18 @@
+import { FilterMetadata } from './filtermetadata';
+import { SortMeta } from './sortmeta';
+/**
+ * Meta data for lazy load event.
+ */
+export interface LazyLoadMeta {
+    first?: number | undefined | null;
+    rows?: number | undefined | null;
+    sortField?: string | string[] | null | undefined;
+    sortOrder?: number | undefined | null;
+    filters?: {
+        [s: string]: FilterMetadata | FilterMetadata[] | undefined;
+    };
+    globalFilter?: string | string[] | undefined | null;
+    multiSortMeta?: SortMeta[] | undefined | null;
+    forceUpdate?: Function;
+    last?: number | undefined | null;
+}

package/api/megamenuitem.d.ts

@@ -1,35 +1,124 @@
 import { QueryParamsHandling } from '@angular/router';
 import { MenuItem } from './menuitem';
+/**
+ * MegaMenuItem API provides the following properties.
+ */
 export interface MegaMenuItem {
+    /**
+     * Text of the item.
+     */
     label?: string;
+    /**
+     * Icon of the item.
+     */
     icon?: string;
+    /**
+     * Callback to execute when item is clicked.
+     */
     command?: (event?: any) => void;
+    /**
+     * External link to navigate when item is clicked.
+     */
     url?: string;
+    /**
+     * An array of children menuitems.
+     */
     items?: MenuItem[][];
+    /**
+     * Specifies whether the mega menu item is expanded.
+     */
     expanded?: boolean;
+    /**
+     * When set as true, disables the menuitem.
+     */
     disabled?: boolean;
+    /**
+     * Whether the dom element of menuitem is created or not.
+     */
     visible?: boolean;
+    /**
+     * Specifies where to open the linked document.
+     */
     target?: string;
+    /**
+     * Configuration for active router link.
+     */
     routerLinkActiveOptions?: any;
+    /**
+     * Defines the item as a separator.
+     */
     separator?: boolean;
+    /**
+     * Value of the badge.
+     */
     badge?: string;
+    /**
+     * Style class of the badge.
+     */
     badgeStyleClass?: string;
+    /**
+     * Inline style of the menuitem.
+     */
     style?: any;
+    /**
+     * Style class of the menuitem.
+     */
     styleClass?: string;
+    /**
+     * Inline style of the item's icon.
+     */
     iconStyle?: any;
+    /**
+     * Tooltip text of the item.
+     */
     title?: string;
+    /**
+     * Identifier of the element.
+     */
     id?: string;
+    /**
+     * Value of HTML data-* attribute.
+     */
     automationId?: any;
+    /**
+     * Specifies tab order of the item.
+     */
     tabindex?: string;
+    /**
+     * RouterLink definition for internal navigation.
+     */
     routerLink?: any;
+    /**
+     * Query parameters for internal navigation via routerLink.
+     */
     queryParams?: {
         [k: string]: any;
     };
+    /**
+     * Sets the hash fragment for the URL.
+     */
     fragment?: string;
+    /**
+     *  How to handle query parameters in the router link for the next navigation. One of:
+        merge : Merge new with current parameters.
+        preserve : Preserve current parameters.k.
+     */
     queryParamsHandling?: QueryParamsHandling;
+    /**
+     * When true, preserves the URL fragment for the next navigation.
+     */
     preserveFragment?: boolean;
+    /**
+     * When true, navigates without pushing a new state into history.
+     */
     skipLocationChange?: boolean;
+    /**
+     * When true, navigates while replacing the current state in history.
+     */
     replaceUrl?: boolean;
+    /**
+     * Developer-defined state that can be passed to any navigation.
+     */
     state?: {
         [k: string]: any;
     };