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

package/api/menuitem.d.ts

@@ -1,41 +1,145 @@
 import { QueryParamsHandling } from '@angular/router';
+/**
+ * MenuItem provides the following properties. Note that not all of them may be utilized by the tabmenu component.
+ */
 export interface MenuItem {
+    /**
+     * 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[];
+    /**
+     * 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;
+    /**
+     * Inline style of the menuitem.
+     */
     style?: any;
+    /**
+     * 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;
+    /**
+     * Inline style of the item's icon.
+     */
     iconStyle?: any;
+    /**
+     * Class of the item's icon.
+     */
     iconClass?: string;
+    /**
+     * Developer-defined state that can be passed to any navigation.
+     */
     state?: {
         [k: string]: any;
     };
+    /**
+     * Options of the item's tooltip.
+     */
     tooltipOptions?: {
         tooltipLabel?: string;
         tooltipPosition?: string;

package/api/message.d.ts

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

package/api/overlayoptions.d.ts

@@ -1,50 +1,176 @@
 import { AnimationEvent } from '@angular/animations';
+/**
+ * Represents the type of overlay mode, which can be 'modal', 'overlay', or undefined.
+ */
 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.
+ */
 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.
+ */
 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.
+ */
 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.
+ */
 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.
+ */
 export interface OverlayOnBeforeShowEvent extends OverlayOnShowEvent {
 }
+/**
+ * Represents an event that occurs before an overlay is hidden.
+ */
 export interface OverlayOnBeforeHideEvent extends OverlayOnBeforeShowEvent {
 }
+/**
+ * Represents an event that occurs when an overlay is hidden.
+ */
 export interface OverlayOnHideEvent extends OverlayOnShowEvent {
 }
+/**
+ * Represents the options for an overlay.
+ */
 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,4 @@ export * from './translationkeys';
 export * from './treedragdropservice';
 export * from './treenode';
 export * from './treenodedragevent';
+export * from './lazyloadmeta';

package/api/selectitem.d.ts

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

package/api/selectitemgroup.d.ts

@@ -1,4 +1,7 @@
 import { SelectItem } from './selectitem';
+/**
+ * Represents a group of select items.
+ */
 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,7 @@
 import { SortMeta } from './sortmeta';
+/**
+ * Represents an event triggered when sorting is applied.
+ */
 export interface SortEvent {
     data?: any[];
     mode?: string;

package/api/sortmeta.d.ts

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

package/api/tablestate.d.ts

@@ -1,19 +1,58 @@
-import { SortMeta } from './sortmeta';
 import { FilterMetadata } from './filtermetadata';
+import { SortMeta } from './sortmeta';
+/**
+ * Represents the state of a table component.
+ */
 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;
     };

package/api/translation.d.ts

@@ -1,3 +1,6 @@
+/**
+ * Represents a set of translated strings used in a component or application.
+ */
 export interface Translation {
     startsWith?: string;
     contains?: string;

package/api/treenode.d.ts

@@ -1,3 +1,6 @@
+/**
+ * Represents a node in a tree data structure.
+ */
 export interface TreeNode<T = any> {
     label?: string;
     data?: T;

package/api/treenodedragevent.d.ts

@@ -1,4 +1,7 @@
 import { TreeNode } from './treenode';
+/**
+ * Represents the event data for a tree node drag operation.
+ */
 export interface TreeNodeDragEvent {
     tree?: any;
     node?: TreeNode;