primeng 16.0.0-rc.1 → 16.0.0

package/api/menuitem.d.ts

@@ -1,55 +1,172 @@
 import { QueryParamsHandling } from '@angular/router';
+import { TooltipOptions } from './tooltipoptions';
+import { MegaMenuItem } from './megamenuitem';
+/**
+ * MenuItem provides the following properties. Note that not all of them may be utilized by the tabmenu component.
+ * @group Interface
+ */
 export interface MenuItem {
+    /**
+     * Text of the item.
+     */
     label?: string;
+    /**
+     * Icon of the item.
+     */
     icon?: string;
-    command?: (event?: any) => void;
+    /**
+     * Callback to execute when item is clicked.
+     */
+    command?(event: MenuItemCommandEvent): void;
+    /**
+     * External link to navigate when item is clicked.
+     */
     url?: string;
+    /**
+     * An array of children menuitems.
+     */
     items?: MenuItem[];
+    /**
+     * Visibility of submenu.
+     */
     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;
+    /**
+     * Whether to escape the label or not. Set to false to display html content.
+     */
     escape?: boolean;
+    /**
+     * Configuration for active router link.
+     */
     routerLinkActiveOptions?: any;
+    /**
+     * Defines the item as a separator.
+     */
     separator?: boolean;
+    /**
+     * Value of the badge.
+     */
     badge?: string;
+    /**
+     * Tooltip of the item.
+     */
     tooltip?: string;
+    /**
+     * Position of the tooltip item.
+     */
     tooltipPosition?: string;
+    /**
+     * Style class of the badge.
+     */
     badgeStyleClass?: string;
-    style?: any;
+    /**
+     * Inline style of the menuitem.
+     */
+    style?: {
+        [klass: string]: any;
+    } | null | undefined;
+    /**
+     * Style class of the menuitem.
+     */
     styleClass?: string;
+    /**
+     * 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;
-    iconStyle?: any;
+    /**
+     * Inline style of the item's icon.
+     */
+    iconStyle?: {
+        [klass: string]: any;
+    } | null | undefined;
+    /**
+     * Class of the item's icon.
+     */
     iconClass?: string;
+    /**
+     * Developer-defined state that can be passed to any navigation.
+     * @see {MenuItemState}
+     */
     state?: {
         [k: string]: any;
     };
-    tooltipOptions?: {
-        tooltipLabel?: string;
-        tooltipPosition?: string;
-        tooltipEvent?: string;
-        appendTo?: any;
-        positionStyle?: string;
-        tooltipStyleClass?: string;
-        tooltipZIndex?: string;
-        escape?: boolean;
-        disabled?: boolean;
-        positionTop?: number;
-        positionLeft?: number;
-        showDelay?: number;
-        hideDelay?: number;
-        life?: number;
-    };
+    /**
+     * Options of the item's tooltip.
+     * @see {TooltipOptions}
+     */
+    tooltipOptions?: TooltipOptions;
+}
+/**
+ * Custom command event
+ * @see {@link MenuItem.command}
+ * @group Events
+ */
+export interface MenuItemCommandEvent {
+    /**
+     * Browser event.
+     */
+    originalEvent?: Event;
+    /**
+     * Selected menu item.
+     */
+    item?: MenuItem | MegaMenuItem;
+    /**
+     * Index of the selected item.
+     */
+    index?: number;
 }

package/api/message.d.ts

@@ -1,3 +1,7 @@
+/**
+ * Deines valid options for the message.
+ * @group Interface
+ */
 export interface Message {
     severity?: string;
     summary?: string;

package/api/messageservice.d.ts

@@ -1,12 +1,31 @@
 import { Message } from './message';
 import * as i0 from "@angular/core";
+/**
+ * Message service used in messages and toast components.
+ * @group Service
+ */
 export declare class MessageService {
     private messageSource;
     private clearSource;
     messageObserver: import("rxjs").Observable<Message | Message[]>;
     clearObserver: import("rxjs").Observable<string>;
+    /**
+     * Inserts single message.
+     * @param {Message} message - Message to be added.
+     * @group Method
+     */
     add(message: Message): void;
+    /**
+     * Insterts new messages.
+     * @param {Message[]} messages - Messages to be added.
+     * @group Method
+     */
     addAll(messages: Message[]): void;
+    /**
+     * Clears the message with the given key.
+     * @param {string} key - Key of the message to be cleared.
+     * @group Method
+     */
     clear(key?: string): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<MessageService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<MessageService>;

package/api/overlayoptions.d.ts

@@ -1,50 +1,188 @@
 import { AnimationEvent } from '@angular/animations';
+/**
+ * Represents the type of overlay mode, which can be 'modal', 'overlay', or undefined.
+ * @group Types
+ */
 export type OverlayModeType = 'modal' | 'overlay' | undefined;
+/**
+ * Represents the type of direction for a responsive overlay, which can be one of the specified values or undefined.
+ * @group Types
+ */
 export type ResponsiveOverlayDirectionType = 'center' | 'top' | 'top-start' | 'top-end' | 'bottom' | 'bottom-start' | 'bottom-end' | 'left' | 'left-start' | 'left-end' | 'right' | 'right-start' | 'right-end' | undefined;
+/**
+ * Represents the options for an overlay listener.
+ * @group Interface
+ */
 export interface OverlayListenerOptions {
+    /**
+     * The type of listener, which can be 'scroll', 'outside', 'resize', or undefined.
+     */
     type?: 'scroll' | 'outside' | 'resize' | undefined;
+    /**
+     * The mode of the overlay listener.
+     */
     mode?: OverlayModeType;
+    /**
+     * Indicates whether the overlay listener is valid.
+     */
     valid?: boolean;
 }
+/**
+ * Represents the options for a responsive overlay.
+ * @group Events
+ */
 export interface ResponsiveOverlayOptions {
+    /**
+     * The inline style for the responsive overlay.
+     */
     style?: any;
+    /**
+     * The CSS class for the responsive overlay.
+     */
     styleClass?: string;
+    /**
+     * The inline style for the content of the responsive overlay.
+     */
     contentStyle?: any;
+    /**
+     * The CSS class for the content of the responsive overlay.
+     */
     contentStyleClass?: string;
+    /**
+     * The breakpoint for the responsive overlay.
+     */
     breakpoint?: string;
+    /**
+     * The media query for the responsive overlay.
+     */
     media?: string;
+    /**
+     * The direction for the responsive overlay.
+     */
     direction?: ResponsiveOverlayDirectionType;
 }
+/**
+ * Represents an event that occurs when an overlay is shown.
+ * @group Events
+ */
 export interface OverlayOnShowEvent {
+    /**
+     * The overlay element.
+     */
     overlay?: HTMLElement | undefined;
+    /**
+     * The target element.
+     */
     target?: HTMLElement | undefined;
+    /**
+     * The mode of the overlay.
+     */
     mode?: OverlayModeType;
 }
+/**
+ * Represents an event that occurs before an overlay is shown.
+ * @extends {OverlayOnShowEvent}
+ * @group Events
+ */
 export interface OverlayOnBeforeShowEvent extends OverlayOnShowEvent {
 }
+/**
+ * Represents an event that occurs before an overlay is hidden.
+ * @extends {OverlayOnBeforeShowEvent}
+ * @group Events
+ */
 export interface OverlayOnBeforeHideEvent extends OverlayOnBeforeShowEvent {
 }
+/**
+ * Represents an event that occurs when an overlay is hidden.
+ * @extends {OverlayOnShowEvent}
+ * @group Events
+ */
 export interface OverlayOnHideEvent extends OverlayOnShowEvent {
 }
+/**
+ * Represents the options for an overlay.
+ * @group Interface
+ */
 export interface OverlayOptions {
+    /**
+     * The mode of the overlay.
+     */
     mode?: OverlayModeType;
+    /**
+     * The inline style for the overlay.
+     */
     style?: any;
+    /**
+     * The CSS class for the overlay.
+     */
     styleClass?: string;
+    /**
+     * The inline style for the content of the overlay.
+     */
     contentStyle?: any;
+    /**
+     * The CSS class for the content of the overlay.
+     */
     contentStyleClass?: string;
+    /**
+     * The target element.
+     */
     target?: any;
+    /**
+     * The element or location where the overlay should be appended.
+     */
     appendTo?: 'body' | HTMLElement | undefined;
+    /**
+     * Indicates whether the overlay should have an auto-generated z-index.
+     */
     autoZIndex?: boolean;
+    /**
+     * The base z-index value for the overlay.
+     */
     baseZIndex?: number;
+    /**
+     * The transition options for showing the overlay.
+     */
     showTransitionOptions?: string;
+    /**
+     * The transition options for hiding the overlay.
+     */
     hideTransitionOptions?: string;
+    /**
+     * Indicates whether the overlay should be hidden when the escape key is pressed.
+     */
     hideOnEscape?: boolean;
+    /**
+     * A listener function for handling events related to the overlay.
+     */
     listener?: (event: Event, options?: OverlayListenerOptions) => boolean | void;
+    /**
+     * The options for a responsive overlay.
+     */
     responsive?: ResponsiveOverlayOptions | undefined;
+    /**
+     * A callback function that is invoked before the overlay is shown.
+     */
     onBeforeShow?: (event?: OverlayOnBeforeShowEvent) => void;
+    /**
+     * A callback function that is invoked when the overlay is shown.
+     */
     onShow?: (event?: OverlayOnShowEvent) => void;
+    /**
+     * A callback function that is invoked before the overlay is hidden.
+     */
     onBeforeHide?: (event?: OverlayOnBeforeHideEvent) => void;
+    /**
+     * A callback function that is invoked when the overlay is hidden.
+     */
     onHide?: (event?: OverlayOnHideEvent) => void;
+    /**
+     * A callback function that is invoked when the overlay's animation starts.
+     */
     onAnimationStart?: (event?: AnimationEvent) => void;
+    /**
+     * A callback function that is invoked when the overlay's animation is done.
+     */
     onAnimationDone?: (event?: AnimationEvent) => void;
 }

package/api/public_api.d.ts

@@ -27,3 +27,7 @@ export * from './translationkeys';
 export * from './treedragdropservice';
 export * from './treenode';
 export * from './treenodedragevent';
+export * from './lazyloadmeta';
+export * from './tooltipoptions';
+export * from './scrolleroptions';
+export * from './treetablenode';

package/api/scrolleroptions.d.ts

@@ -0,0 +1,116 @@
+/**
+ * Options for the scroller.
+ * @group Interface
+ */
+export interface ScrollerOptions {
+    /**
+     * Unique identifier of the element.
+     */
+    id?: string | undefined;
+    /**
+     * Inline style of the component.
+     */
+    style?: {
+        [klass: string]: any;
+    } | null | undefined;
+    /**
+     * Style class of the element.
+     */
+    styleClass?: string | undefined;
+    /**
+     * Index of the element in tabbing order.
+     */
+    tabindex?: number | undefined;
+    /**
+     * An array of objects to display.
+     */
+    items?: any[];
+    /**
+     * The height/width of item according to orientation.
+     */
+    itemSize?: any;
+    /**
+     * Height of the scroll viewport.
+     */
+    scrollHeight?: string | undefined;
+    /**
+     * Width of the scroll viewport.
+     */
+    scrollWidth?: string | undefined;
+    /**
+     * The orientation of scrollbar.
+     */
+    orientation?: 'vertical' | 'horizontal' | 'both';
+    /**
+     * Used to specify how many items to load in each load method in lazy mode.
+     */
+    step?: number | undefined;
+    /**
+     * Delay in scroll before new data is loaded.
+     */
+    delay?: number | undefined;
+    /**
+     * Delay after window's resize finishes.
+     */
+    resizeDelay?: number | undefined;
+    /**
+     * Used to append each loaded item to top without removing any items from the DOM. Using very large data may cause the browser to crash.
+     */
+    appendOnly?: boolean;
+    /**
+     * Specifies whether the scroller should be displayed inline or not.
+     */
+    inline?: boolean;
+    /**
+     * Defines if data is loaded and interacted with in lazy manner.
+     */
+    lazy?: boolean;
+    /**
+     * If disabled, the scroller feature is eliminated and the content is displayed directly.
+     */
+    disabled?: boolean;
+    /**
+     * Used to implement a custom loader instead of using the loader feature in the scroller.
+     */
+    loaderDisabled?: boolean;
+    /**
+     * Columns to display.
+     */
+    columns?: any[] | undefined;
+    /**
+     * Used to implement a custom spacer instead of using the spacer feature in the scroller.
+     */
+    showSpacer?: boolean;
+    /**
+     * Defines whether to show loader.
+     */
+    showLoader?: boolean;
+    /**
+     * Determines how many additional elements to add to the DOM outside of the view. According to the scrolls made up and down, extra items are added in a certain algorithm in the form of multiples of this number. Default value is half the number of items shown in the view.
+     */
+    numToleratedItems?: any;
+    /**
+     * Defines whether the data is loaded.
+     */
+    loading?: boolean;
+    /**
+     * Defines whether to dynamically change the height or width of scrollable container.
+     */
+    autoSize?: boolean;
+    /**
+     * Function to optimize the dom operations by delegating to ngForTrackBy, default algoritm checks for object identity.
+     */
+    trackBy?: Function;
+    /**
+     * Callback to invoke in lazy mode to load new data.
+     */
+    onLazyLoad?: Function | undefined;
+    /**
+     * Callback to invoke when scroll position changes.
+     */
+    onScroll?: Function | undefined;
+    /**
+     * Callback to invoke when scroll position and item's range in view changes.
+     */
+    onScrollIndexChange?: Function | undefined;
+}

package/api/selectitem.d.ts

@@ -1,3 +1,7 @@
+/**
+ * Represents an option item.
+ * @group Interface
+ */
 export interface SelectItem<T = any> {
     label?: string;
     value: T;

package/api/selectitemgroup.d.ts

@@ -1,4 +1,8 @@
 import { SelectItem } from './selectitem';
+/**
+ * Represents a group of select items.
+ * @group Interface
+ */
 export interface SelectItemGroup {
     label: string;
     value?: any;

package/api/shared.d.ts

@@ -11,8 +11,8 @@ export declare class Footer {
 }
 export declare class PrimeTemplate {
     template: TemplateRef<any>;
-    type: string;
-    name: string;
+    type: string | undefined;
+    name: string | undefined;
     constructor(template: TemplateRef<any>);
     getType(): string;
     static ɵfac: i0.ɵɵFactoryDeclaration<PrimeTemplate, never>;

package/api/sortevent.d.ts

@@ -1,4 +1,8 @@
 import { SortMeta } from './sortmeta';
+/**
+ * Represents an event triggered when sorting is applied.
+ * @group Interface
+ */
 export interface SortEvent {
     data?: any[];
     mode?: string;

package/api/sortmeta.d.ts

@@ -1,3 +1,7 @@
+/**
+ * Represents metadata for sorting.
+ * @group Interface
+ */
 export interface SortMeta {
     field: string;
     order: number;

package/api/tablestate.d.ts

@@ -1,19 +1,59 @@
-import { SortMeta } from './sortmeta';
 import { FilterMetadata } from './filtermetadata';
+import { SortMeta } from './sortmeta';
+/**
+ * Represents the state of a table component.
+ * @group Interface
+ */
 export interface TableState {
+    /**
+     * The index of the first row to be displayed.
+     */
     first?: number;
+    /**
+     * The number of rows to be displayed per page.
+     */
     rows?: number;
+    /**
+     * The field used for sorting.
+     */
     sortField?: string;
+    /**
+     * The sort order.
+     */
     sortOrder?: number;
+    /**
+     * An array of sort metadata when multiple sorting is applied.
+     */
     multiSortMeta?: SortMeta[];
+    /**
+     * The filters to be applied to the table.
+     */
     filters?: {
         [s: string]: FilterMetadata | FilterMetadata[];
     };
+    /**
+     * The column widths for the table.
+     */
     columnWidths?: string;
+    /**
+     * The width of the table.
+     */
     tableWidth?: string;
+    /**
+     * The width of the wrapper element containing the table.
+     */
     wrapperWidth?: string;
+    /**
+     * The selected item(s) in the table.
+     */
     selection?: any;
+    /**
+     * The order of the columns in the table.
+     */
     columnOrder?: string[];
+    /**
+     * The keys of the expanded rows in the table.
+     */
     expandedRowKeys?: {
         [s: string]: boolean;
     };