@pepperi-addons/ngx-lib 0.4.2-beta.137 → 0.4.2-beta.139

package/list/list-views.component.d.ts

@@ -0,0 +1,35 @@
+import { OnInit, EventEmitter } from '@angular/core';
+import { PepSizeType, PepStyleType } from '@pepperi-addons/ngx-lib';
+import { PepMenuItem, IPepMenuItemClickEvent } from '@pepperi-addons/ngx-lib/menu';
+import * as i0 from "@angular/core";
+export declare type PepListViewDisplayType = 'menu' | 'buttons';
+export declare class IPepListView {
+    key: string;
+    iconName: string;
+    title?: string;
+}
+export interface IListViewChangeEvent {
+    source: IPepListView;
+}
+export declare class PepListViewsComponent implements OnInit {
+    private _views;
+    set views(value: Array<IPepListView>);
+    get views(): Array<IPepListView>;
+    private _currentView;
+    set currentView(value: IPepListView);
+    get currentView(): IPepListView;
+    displayType: PepListViewDisplayType;
+    styleType: PepStyleType;
+    sizeType: PepSizeType;
+    classNames: string;
+    change: EventEmitter<IListViewChangeEvent>;
+    menuItems: Array<PepMenuItem>;
+    currentItem: PepMenuItem;
+    ngOnInit(): void;
+    onMenuItemClicked(menuItemClickEvent: IPepMenuItemClickEvent): void;
+    onViewChanged(view: IPepListView): void;
+    private raiseChangeEvent;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PepListViewsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PepListViewsComponent, "pep-list-views", never, { "views": "views"; "currentView": "currentView"; "displayType": "displayType"; "styleType": "styleType"; "sizeType": "sizeType"; "classNames": "classNames"; }, { "change": "change"; }, never, never, false>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PepListViewsComponent>;
+}

package/list/list.component.d.ts

@@ -0,0 +1,177 @@
+import { EventEmitter, OnInit, Renderer2, ElementRef, ChangeDetectorRef, OnDestroy, OnChanges, NgZone } from '@angular/core';
+import { PepLayoutService, PepScreenSizeType, PepSessionService, UIControl, ObjectsDataRow } from '@pepperi-addons/ngx-lib';
+import { IPepFormFieldValueChangeEvent, IPepFormFieldClickEvent } from '@pepperi-addons/ngx-lib/form';
+import { IPageInfo } from './virtual-scroller';
+import { IPepListLoadItemsEvent, IPepListSortingChangeEvent, IPepListItemClickEvent, PepListSelectionType, PepListViewType, PepSelectionData, PepListPagerType, IPepListLoadPageEvent, IPepListStartIndexChangeEvent, PepListCardSizeType, PepListTableViewType, IPepListSortingData } from './list.model';
+import { IPepListPagerChangeEvent } from './list-pager.component';
+import * as i0 from "@angular/core";
+export declare class PepListComponent implements OnInit, OnChanges, OnDestroy {
+    private hostElement;
+    private layoutService;
+    private sessionService;
+    private cd;
+    private renderer;
+    private zone;
+    static TOP_ITEMS_DEFAULT: number;
+    static TOP_ITEMS_TABLE: number;
+    static TOP_ITEMS_THUMBNAILS: number;
+    static TOP_ITEMS_ARRAY: number;
+    static SELECTED_ITEMS_STATE_KEY: string;
+    static UN_SELECTED_ITEMS_STATE_KEY: string;
+    static ALL_SELECTED_STATE_KEY: string;
+    static SORT_BY_STATE_KEY: string;
+    static ASCENDING_STATE_KEY: string;
+    static MINIMUM_COLUMN_WIDTH: number;
+    set sorting(value: IPepListSortingData);
+    get sorting(): IPepListSortingData;
+    cacheSize: number;
+    noDataFoundMsg: string;
+    selectionTypeForActions: PepListSelectionType;
+    showCardSelection: boolean;
+    hideAllSelectionInMulti: boolean;
+    cardSize: PepListCardSizeType;
+    tableViewType: PepListTableViewType;
+    private _viewType;
+    set viewType(value: PepListViewType);
+    get viewType(): PepListViewType;
+    firstFieldAsLink: boolean;
+    supportSorting: boolean;
+    supportResizing: boolean;
+    private _parentScroll;
+    set parentScroll(value: Element | Window);
+    get parentScroll(): Element | Window;
+    disabled: boolean;
+    private _lockEvents;
+    set lockEvents(value: boolean);
+    get lockEvents(): boolean;
+    lockItemInnerEvents: boolean;
+    printMode: boolean;
+    isReport: boolean;
+    zebraStripes: boolean;
+    totalsRow: any[];
+    pagerType: PepListPagerType;
+    pageSize: number;
+    pageIndex: number;
+    bufferAmount: number;
+    scrollAnimationTime: number;
+    scrollDebounceTime: number;
+    scrollThrottlingTime: number;
+    private _useAsWebComponent;
+    set useAsWebComponent(value: boolean);
+    get useAsWebComponent(): boolean;
+    itemClick: EventEmitter<IPepListItemClickEvent>;
+    fieldClick: EventEmitter<IPepFormFieldClickEvent>;
+    valueChange: EventEmitter<IPepFormFieldValueChangeEvent>;
+    sortingChange: EventEmitter<IPepListSortingChangeEvent>;
+    selectedItemsChange: EventEmitter<number>;
+    selectedItemChange: EventEmitter<any>;
+    selectAllClick: EventEmitter<any>;
+    listLoad: EventEmitter<void>;
+    loadItems: EventEmitter<IPepListLoadItemsEvent>;
+    loadPage: EventEmitter<IPepListLoadPageEvent>;
+    startIndexChange: EventEmitter<IPepListStartIndexChangeEvent>;
+    private virtualScroller;
+    selectAllCB: any;
+    private _layout;
+    get layout(): UIControl;
+    totalRows: number;
+    isTable: boolean;
+    private hasColumnWidthOfTypePercentage;
+    private _items;
+    get items(): Array<ObjectsDataRow>;
+    private itemsCounter;
+    currentPageItems: Array<ObjectsDataRow>;
+    SEPARATOR: string;
+    isAllSelected: boolean;
+    selectedItems: Map<string, string>;
+    unSelectedItems: Map<string, string>;
+    private currentTween;
+    selectedItemId: string;
+    hoveredItemId: string;
+    private containerWidth;
+    private tableScrollWidth;
+    private _loadingItemsFromApi;
+    get loadingItemsFromApi(): boolean;
+    screenSize: PepScreenSizeType;
+    deviceHasMouse: boolean;
+    pressedColumn: string;
+    pressedColumnIndex: number;
+    startX: number;
+    startWidth: number;
+    tableStartWidth: number;
+    private lastColumnsWidth;
+    isAsc: boolean;
+    sortBy: string;
+    isUserSelected: boolean;
+    checkForChanges: any;
+    calculatedObjectHeight: string;
+    constructor(hostElement: ElementRef, layoutService: PepLayoutService, sessionService: PepSessionService, cd: ChangeDetectorRef, renderer: Renderer2, zone: NgZone);
+    ngOnInit(): void;
+    ngOnChanges(changes: any): void;
+    ngOnDestroy(): void;
+    getCachedItemsNumber(): number;
+    private getScrollingElement;
+    private scrollToTop;
+    private getSelectionCheckBoxWidth;
+    private setContainerWidth;
+    private saveSortingToSession;
+    private getTopItems;
+    private disableScroll;
+    private toggleLoadingItemsFropApi;
+    private updateCurrentPageItems;
+    private setSelectionItems;
+    private getUniqItemId;
+    private setLayout;
+    private setLastColumnsWidth;
+    private setVirtualScrollWidth;
+    private setColumnsWidth;
+    private calcColumnsWidth;
+    private calcObjectHeight;
+    private initResizeData;
+    private getParent;
+    private cleanItems;
+    private initVariablesFromSession;
+    private getIsAllSelected;
+    private getNumberOfStartItems;
+    private setItemClicked;
+    private exportFunctionsOnHostElement;
+    getisItemDisabled(item: ObjectsDataRow): boolean;
+    getIsAllSelectedForActions(): boolean;
+    setIsAllSelected(isChecked: boolean): void;
+    selectAllItemsForActions(e: any): void;
+    raiseStartIndexChange(startIndex?: number): void;
+    getIsItemSelected(item: ObjectsDataRow): boolean;
+    selectItemForActions(e: any, itemId: string, isSelectableForActions: boolean, itemType?: string): void;
+    itemClicked(e: any, item: ObjectsDataRow): void;
+    onTableRowMouseEnter(event: any, itemId: string, itemType: string): void;
+    onTableRowMouseLeave(event: any, itemId: string, itemType: string): void;
+    onCardMouseEnter(event: any, itemId: string, itemType: string): void;
+    onCardMouseLeave(event: any, itemId: string, itemType: string): void;
+    clear(): void;
+    setSelectedIds(selectedIds: string[], items?: any): void;
+    setSelectionDataInSession(): void;
+    initListData(layout: UIControl, totalRows: number, items: ObjectsDataRow[]): void;
+    updateItems(items: ObjectsDataRow[], event?: IPepListLoadItemsEvent): void;
+    updatePage(items: ObjectsDataRow[], event: IPepListLoadPageEvent): void;
+    updateItem(data: ObjectsDataRow): void;
+    scrollToIndex(index: number, alignToBeginning?: boolean, additionalOffset?: number, animationMilliseconds?: number, animationCompletedCallback?: () => void): void;
+    updateItemProperties(itemToUpdate: ObjectsDataRow, data: ObjectsDataRow): void;
+    getSelectedItemsData(isForEdit?: boolean): PepSelectionData;
+    getIsItemEditable(uid: string): boolean;
+    getItemDataByID(uid: string): ObjectsDataRow;
+    refresh(refreshCompletedCallback?: () => void): void;
+    onWinResize(e: any): void;
+    onListResizeStart(event: any, columnKey: string, columnIndex: number): void;
+    onListResize(event: any): void;
+    onListResizeEnd(event: any): void;
+    onListSortingChange(sortBy: string, isAsc: boolean, event?: any): void;
+    onListHeaderMouseEnter(event: any): void;
+    onListHeaderMouseLeave(event: any): void;
+    onPagerChange(event: IPepListPagerChangeEvent): void;
+    onVirtualScrollerChange(event: IPageInfo): void;
+    onListLoad(): void;
+    onValueChanged(valueChange: IPepFormFieldValueChangeEvent): void;
+    onCustomizeFieldClick(customizeFieldClickedData: IPepFormFieldClickEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PepListComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PepListComponent, "pep-list", never, { "sorting": "sorting"; "cacheSize": "cacheSize"; "noDataFoundMsg": "noDataFoundMsg"; "selectionTypeForActions": "selectionTypeForActions"; "showCardSelection": "showCardSelection"; "hideAllSelectionInMulti": "hideAllSelectionInMulti"; "cardSize": "cardSize"; "tableViewType": "tableViewType"; "viewType": "viewType"; "firstFieldAsLink": "firstFieldAsLink"; "supportSorting": "supportSorting"; "supportResizing": "supportResizing"; "parentScroll": "parentScroll"; "disabled": "disabled"; "lockEvents": "lockEvents"; "lockItemInnerEvents": "lockItemInnerEvents"; "printMode": "printMode"; "isReport": "isReport"; "zebraStripes": "zebraStripes"; "totalsRow": "totalsRow"; "pagerType": "pagerType"; "pageSize": "pageSize"; "pageIndex": "pageIndex"; "bufferAmount": "bufferAmount"; "scrollAnimationTime": "scrollAnimationTime"; "scrollDebounceTime": "scrollDebounceTime"; "scrollThrottlingTime": "scrollThrottlingTime"; "useAsWebComponent": "useAsWebComponent"; }, { "itemClick": "itemClick"; "fieldClick": "fieldClick"; "valueChange": "valueChange"; "sortingChange": "sortingChange"; "selectedItemsChange": "selectedItemsChange"; "selectedItemChange": "selectedItemChange"; "selectAllClick": "selectAllClick"; "listLoad": "listLoad"; "loadItems": "loadItems"; "loadPage": "loadPage"; "startIndexChange": "startIndexChange"; }, never, never, false>;
+}

package/list/list.model.d.ts

@@ -0,0 +1,32 @@
+import { ObjectsDataRow } from '@pepperi-addons/ngx-lib';
+export declare type PepListSelectionType = 'none' | 'single' | 'multi';
+export declare type PepListPagerType = 'pages' | 'scroll';
+export declare type PepListViewType = '' | 'cards' | 'lines' | 'table';
+export declare type PepListCardSizeType = 'sm' | 'md';
+export declare type PepListTableViewType = 'compact' | 'regular';
+export interface IPepListItemClickEvent {
+    source: ObjectsDataRow;
+    viewType: PepListViewType;
+}
+export declare class PepSelectionData {
+    selectionType: number;
+    rows: Array<any>;
+    rowTypes: Array<any>;
+}
+export interface IPepListLoadItemsEvent {
+    fromIndex: number;
+    toIndex: number;
+}
+export interface IPepListLoadPageEvent {
+    pageIndex: number;
+    pageSize: number;
+}
+export interface IPepListStartIndexChangeEvent {
+    startIndex: number;
+}
+export declare const DEFAULT_PAGE_SIZE = 50;
+export interface IPepListSortingData {
+    sortBy: string;
+    isAsc: boolean;
+}
+export declare type IPepListSortingChangeEvent = IPepListSortingData;

package/list/list.module.d.ts

@@ -0,0 +1,34 @@
+import { PepIconRegistry } from '@pepperi-addons/ngx-lib/icon';
+import * as i0 from "@angular/core";
+import * as i1 from "./list.component";
+import * as i2 from "./list-actions.component";
+import * as i3 from "./list-carousel.component";
+import * as i4 from "./list-chooser.component";
+import * as i5 from "./list-pager.component";
+import * as i6 from "./list-sorting.component";
+import * as i7 from "./list-total.component";
+import * as i8 from "./list-views.component";
+import * as i9 from "./list.pipes";
+import * as i10 from "@angular/common";
+import * as i11 from "@angular/material/core";
+import * as i12 from "@angular/material/button";
+import * as i13 from "@angular/material/checkbox";
+import * as i14 from "@angular/material/radio";
+import * as i15 from "@angular/material/icon";
+import * as i16 from "@angular/material/menu";
+import * as i17 from "@pepperi-addons/ngx-lib";
+import * as i18 from "@pepperi-addons/ngx-lib/bread-crumbs";
+import * as i19 from "@pepperi-addons/ngx-lib/button";
+import * as i20 from "@pepperi-addons/ngx-lib/carousel";
+import * as i21 from "@pepperi-addons/ngx-lib/icon";
+import * as i22 from "@pepperi-addons/ngx-lib/form";
+import * as i23 from "@pepperi-addons/ngx-lib/menu";
+import * as i24 from "@pepperi-addons/ngx-lib/textbox";
+import * as i25 from "./virtual-scroller";
+export declare class PepListModule {
+    private pepIconRegistry;
+    constructor(pepIconRegistry: PepIconRegistry);
+    static ɵfac: i0.ɵɵFactoryDeclaration<PepListModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<PepListModule, [typeof i1.PepListComponent, typeof i2.PepListActionsComponent, typeof i3.PepListCarouselComponent, typeof i4.PepListChooserComponent, typeof i5.PepListPagerComponent, typeof i6.PepListSortingComponent, typeof i7.PepListTotalComponent, typeof i8.PepListViewsComponent, typeof i9.IsItemSelectedPipe, typeof i9.IsItemDisabledPipe], [typeof i10.CommonModule, typeof i11.MatCommonModule, typeof i12.MatButtonModule, typeof i13.MatCheckboxModule, typeof i14.MatRadioModule, typeof i15.MatIconModule, typeof i16.MatMenuModule, typeof i17.PepNgxLibModule, typeof i18.PepBreadCrumbsModule, typeof i19.PepButtonModule, typeof i20.PepCarouselModule, typeof i21.PepIconModule, typeof i22.PepFormModule, typeof i23.PepMenuModule, typeof i24.PepTextboxModule, typeof i25.VirtualScrollerModule], [typeof i1.PepListComponent, typeof i2.PepListActionsComponent, typeof i3.PepListCarouselComponent, typeof i4.PepListChooserComponent, typeof i5.PepListPagerComponent, typeof i6.PepListSortingComponent, typeof i7.PepListTotalComponent, typeof i8.PepListViewsComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<PepListModule>;
+}

package/list/list.pipes.d.ts

@@ -0,0 +1,16 @@
+import { PipeTransform } from '@angular/core';
+import { ObjectsDataRow } from '@pepperi-addons/ngx-lib';
+import { PepListSelectionType } from './list.model';
+import * as i0 from "@angular/core";
+export declare class IsItemSelectedPipe implements PipeTransform {
+    SEPARATOR: string;
+    private getUniqItemId;
+    transform(item: ObjectsDataRow, selectionTypeForActions: PepListSelectionType, selectedItemId: string, isAllSelected: boolean, selectedItems: Map<string, string>, unSelectedItems: Map<string, string>): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IsItemSelectedPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<IsItemSelectedPipe, "isItemSelected", false>;
+}
+export declare class IsItemDisabledPipe implements PipeTransform {
+    transform(item: ObjectsDataRow, lockItemInnerEvents: boolean, printMode: boolean): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IsItemDisabledPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<IsItemDisabledPipe, "isItemDisabled", false>;
+}

package/list/public-api.d.ts

@@ -0,0 +1,10 @@
+export * from './list.module';
+export * from './list.model';
+export * from './list.component';
+export * from './list-actions.component';
+export * from './list-carousel.component';
+export * from './list-chooser.component';
+export * from './list-pager.component';
+export * from './list-sorting.component';
+export * from './list-total.component';
+export * from './list-views.component';

package/list/virtual-scroller.d.ts

@@ -0,0 +1,183 @@
+import { ChangeDetectorRef, ElementRef, EventEmitter, NgZone, OnChanges, OnDestroy, OnInit, Renderer2 } from '@angular/core';
+import * as tween from '@tweenjs/tween.js';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+export interface VirtualScrollerDefaultOptions {
+    checkResizeInterval: number;
+    modifyOverflowStyleOfParentScroll: boolean;
+    resizeBypassRefreshThreshold: number;
+    scrollAnimationTime: number;
+    scrollDebounceTime: number;
+    scrollThrottlingTime: number;
+    scrollbarHeight?: number;
+    scrollbarWidth?: number;
+    stripedTable: boolean;
+}
+export declare function VIRTUAL_SCROLLER_DEFAULT_OPTIONS_FACTORY(): VirtualScrollerDefaultOptions;
+export interface WrapGroupDimensions {
+    maxChildSizePerWrapGroup: WrapGroupDimension[];
+    numberOfKnownWrapGroupChildSizes: number;
+    sumOfKnownWrapGroupChildHeights: number;
+    sumOfKnownWrapGroupChildWidths: number;
+}
+export interface WrapGroupDimension {
+    childHeight: number;
+    childWidth: number;
+    items: any[];
+}
+export interface IDimensions {
+    childHeight: number;
+    childWidth: number;
+    itemCount: number;
+    itemsPerPage: number;
+    itemsPerWrapGroup: number;
+    maxScrollPosition: number;
+    pageCount_fractional: number;
+    scrollLength: number;
+    viewportLength: number;
+    wrapGroupsPerPage: number;
+}
+export declare type ScrollDirectionType = 'backward' | 'forward';
+export interface IPageInfo {
+    endIndex: number;
+    endIndexWithBuffer: number;
+    maxScrollPosition: number;
+    scrollEndPosition: number;
+    scrollStartPosition: number;
+    scrollDirection?: ScrollDirectionType;
+    startIndex: number;
+    startIndexWithBuffer: number;
+}
+export interface IViewport extends IPageInfo {
+    padding: number;
+    scrollLength: number;
+}
+export declare class VirtualScrollerComponent implements OnInit, OnChanges, OnDestroy {
+    protected readonly element: ElementRef;
+    protected readonly renderer: Renderer2;
+    protected readonly zone: NgZone;
+    protected changeDetectorRef: ChangeDetectorRef;
+    viewPortItems: any[];
+    window: Window & typeof globalThis;
+    get viewPortInfo(): IPageInfo;
+    protected _disable: boolean;
+    get disable(): boolean;
+    set disable(value: boolean);
+    executeRefreshOutsideAngularZone: boolean;
+    protected _enableUnequalChildrenSizes: boolean;
+    get enableUnequalChildrenSizes(): boolean;
+    set enableUnequalChildrenSizes(value: boolean);
+    RTL: boolean;
+    useMarginInsteadOfTranslate: boolean;
+    modifyOverflowStyleOfParentScroll: boolean;
+    stripedTable: boolean;
+    scrollbarWidth: number;
+    scrollbarHeight: number;
+    childWidth: number;
+    childHeight: number;
+    ssrChildWidth: number;
+    ssrChildHeight: number;
+    ssrViewportWidth: number;
+    ssrViewportHeight: number;
+    protected _bufferAmount: number;
+    get bufferAmount(): number;
+    set bufferAmount(value: number);
+    scrollAnimationTime: number;
+    resizeBypassRefreshThreshold: number;
+    protected _scrollThrottlingTime: number;
+    get scrollThrottlingTime(): number;
+    set scrollThrottlingTime(value: number);
+    protected _scrollDebounceTime: number;
+    get scrollDebounceTime(): number;
+    set scrollDebounceTime(value: number);
+    protected onScroll: () => void;
+    protected updateOnScrollFunction(): void;
+    protected checkScrollElementResizedTimer: number;
+    protected _checkResizeInterval: number;
+    get checkResizeInterval(): number;
+    set checkResizeInterval(value: number);
+    protected _items: any[];
+    get items(): any[];
+    set items(value: any[]);
+    compareItems: (item1: any, item2: any) => boolean;
+    protected _horizontal: boolean;
+    get horizontal(): boolean;
+    set horizontal(value: boolean);
+    protected revertParentOverscroll(): void;
+    protected oldParentScrollOverflow: {
+        x: string;
+        y: string;
+    };
+    protected _parentScroll: Element | Window;
+    get parentScroll(): Element | Window;
+    set parentScroll(value: Element | Window);
+    vsChildRectChange: EventEmitter<DOMRect>;
+    vsUpdate: EventEmitter<any[]>;
+    vsChange: EventEmitter<IPageInfo>;
+    vsStart: EventEmitter<IPageInfo>;
+    vsEnd: EventEmitter<IPageInfo>;
+    contentElementRef: ElementRef;
+    protected invisiblePaddingElementRef: ElementRef;
+    protected headerElementRef: ElementRef;
+    protected containerElementRef: ElementRef;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    ngOnChanges(changes: any): void;
+    ngDoCheck(): void;
+    refresh(refreshCompletedCallback?: () => void): void;
+    invalidateAllCachedMeasurements(): void;
+    invalidateCachedMeasurementForItem(item: any): void;
+    invalidateCachedMeasurementAtIndex(index: number): void;
+    scrollInto(item: any, alignToBeginning?: boolean, additionalOffset?: number, animationMilliseconds?: number, animationCompletedCallback?: () => void): void;
+    scrollToIndex(index: number, alignToBeginning?: boolean, additionalOffset?: number, animationMilliseconds?: number, animationCompletedCallback?: () => void): void;
+    protected scrollToIndex_internal(index: number, alignToBeginning?: boolean, additionalOffset?: number, animationMilliseconds?: number, animationCompletedCallback?: () => void): void;
+    scrollToPosition(scrollPosition: number, animationMilliseconds?: number, animationCompletedCallback?: () => void): void;
+    protected isAngularUniversalSSR: boolean;
+    constructor(element: ElementRef, renderer: Renderer2, zone: NgZone, changeDetectorRef: ChangeDetectorRef, platformId: any, options: VirtualScrollerDefaultOptions);
+    getElementSize(element: HTMLElement): any;
+    getContent(): any;
+    protected previousScrollBoundingRect: DOMRect;
+    protected checkScrollElementResized(): void;
+    protected _invisiblePaddingProperty: any;
+    protected _offsetType: any;
+    protected _scrollType: any;
+    protected _pageOffsetType: any;
+    protected _childScrollDim: any;
+    protected _translateDir: any;
+    protected _marginDir: any;
+    protected updateDirection(): void;
+    protected debounce(func: () => void, wait: number, ...args: any[]): () => void;
+    protected throttleTrailing(func: () => void, wait: number, ...args: any[]): () => void;
+    protected calculatedScrollbarWidth: number;
+    protected calculatedScrollbarHeight: number;
+    protected padding: number;
+    protected previousViewPort: IViewport;
+    protected currentTween: tween.Tween;
+    protected cachedItemsLength: number;
+    protected disposeScrollHandler: () => void | undefined;
+    protected disposeResizeHandler: () => void | undefined;
+    protected refresh_internal(itemsArrayModified: boolean, refreshCompletedCallback?: () => void, maxRunTimes?: number): void;
+    protected getScrollElement(): HTMLElement;
+    protected addScrollEventHandlers(): void;
+    protected removeScrollEventHandlers(): void;
+    protected getElementsOffset(): number;
+    protected countItemsPerWrapGroup(): number;
+    protected getScrollStartPosition(): number;
+    protected minMeasuredChildWidth: number;
+    protected minMeasuredChildHeight: number;
+    protected wrapGroupDimensions: WrapGroupDimensions;
+    protected resetWrapGroupDimensions(): void;
+    protected calculateDimensions(): IDimensions;
+    protected cachedPageSize: number;
+    protected previousScrollNumberElements: number;
+    protected calculatePadding(arrayStartIndexWithBuffer: number, dimensions: IDimensions): number;
+    protected calculatePageInfo(scrollPosition: number, dimensions: IDimensions): IPageInfo;
+    protected calculateViewport(): IViewport;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VirtualScrollerComponent, [null, null, null, null, null, { optional: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<VirtualScrollerComponent, "virtual-scroller,[virtualScroller]", ["virtualScroller"], { "disable": "disable"; "executeRefreshOutsideAngularZone": "executeRefreshOutsideAngularZone"; "enableUnequalChildrenSizes": "enableUnequalChildrenSizes"; "RTL": "RTL"; "useMarginInsteadOfTranslate": "useMarginInsteadOfTranslate"; "modifyOverflowStyleOfParentScroll": "modifyOverflowStyleOfParentScroll"; "stripedTable": "stripedTable"; "scrollbarWidth": "scrollbarWidth"; "scrollbarHeight": "scrollbarHeight"; "childWidth": "childWidth"; "childHeight": "childHeight"; "ssrChildWidth": "ssrChildWidth"; "ssrChildHeight": "ssrChildHeight"; "ssrViewportWidth": "ssrViewportWidth"; "ssrViewportHeight": "ssrViewportHeight"; "bufferAmount": "bufferAmount"; "scrollAnimationTime": "scrollAnimationTime"; "resizeBypassRefreshThreshold": "resizeBypassRefreshThreshold"; "scrollThrottlingTime": "scrollThrottlingTime"; "scrollDebounceTime": "scrollDebounceTime"; "checkResizeInterval": "checkResizeInterval"; "items": "items"; "compareItems": "compareItems"; "horizontal": "horizontal"; "parentScroll": "parentScroll"; }, { "vsChildRectChange": "vsChildRectChange"; "vsUpdate": "vsUpdate"; "vsChange": "vsChange"; "vsStart": "vsStart"; "vsEnd": "vsEnd"; }, ["headerElementRef", "containerElementRef"], ["*"], false>;
+}
+export declare class VirtualScrollerModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<VirtualScrollerModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<VirtualScrollerModule, [typeof VirtualScrollerComponent], [typeof i1.CommonModule], [typeof VirtualScrollerComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<VirtualScrollerModule>;
+}

package/menu/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+/// <amd-module name="@pepperi-addons/ngx-lib/menu" />
+export * from './public-api';

package/menu/menu-item.component.d.ts

@@ -0,0 +1,28 @@
+import { EventEmitter, OnDestroy } from '@angular/core';
+import { PepMenuItem, IPepMenuItemClickEvent, PepMenuType, PepMenuItemParent } from './menu.model';
+import * as i0 from "@angular/core";
+export declare class PepInternalMenuItem extends PepMenuItem {
+    selected?: boolean;
+}
+export declare class PepMenuItemComponent implements OnDestroy {
+    type: PepMenuType;
+    parent: PepMenuItemParent;
+    items: Array<PepInternalMenuItem>;
+    private _selectedItem;
+    set selectedItem(selectedItem: PepInternalMenuItem);
+    get selectedItem(): PepInternalMenuItem;
+    xPosition: 'before' | 'after';
+    subMenuIconName: string;
+    childMenu: any;
+    menuItemClick: EventEmitter<IPepMenuItemClickEvent>;
+    ngOnDestroy(): void;
+    private clearSelectedItem;
+    private clearSelectedChildren;
+    private selectParentAndChildren;
+    private updateSelectedParent;
+    private updateSelectedItem;
+    onChildClicked(click: IPepMenuItemClickEvent): void;
+    onMenuItemClicked(item: PepMenuItem): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PepMenuItemComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PepMenuItemComponent, "pep-menu-item", never, { "type": "type"; "parent": "parent"; "items": "items"; "selectedItem": "selectedItem"; "xPosition": "xPosition"; "subMenuIconName": "subMenuIconName"; }, { "menuItemClick": "menuItemClick"; }, never, never, false>;
+}

package/menu/menu.component.d.ts

@@ -0,0 +1,48 @@
+import { EventEmitter, OnChanges, OnDestroy } from '@angular/core';
+import { PepLayoutService, PepStyleType, PepSizeType, PepScreenSizeType } from '@pepperi-addons/ngx-lib';
+import { PepIconType } from '@pepperi-addons/ngx-lib/icon';
+import { PepMenuItem, IPepMenuItemClickEvent, IPepMenuStateChangeEvent, PepMenuStateType, PepMenuType } from './menu.model';
+import * as i0 from "@angular/core";
+export declare class PepMenuComponent implements OnChanges, OnDestroy {
+    layoutService: PepLayoutService;
+    text: string;
+    /**
+     * The icon name to show on the menu, look in (@link icon -> All icons), default icon `system_menu`
+     *
+     * @type {PepIconType} See {@link PepIconType}
+     * @memberof PepMenuComponent
+     */
+    iconName: PepIconType;
+    type: PepMenuType;
+    styleType: PepStyleType;
+    sizeType: PepSizeType;
+    classNames: string;
+    xPosition: 'before' | 'after';
+    hideOnEmptyItems: boolean;
+    private _items;
+    set items(items: Array<PepMenuItem>);
+    get items(): Array<PepMenuItem>;
+    selectedItem: PepMenuItem;
+    disabled: boolean;
+    stateChange: EventEmitter<IPepMenuStateChangeEvent>;
+    menuItemClick: EventEmitter<IPepMenuItemClickEvent>;
+    menuClick: EventEmitter<void>;
+    state: PepMenuStateType;
+    PepScreenSizeType: typeof PepScreenSizeType;
+    screenSize: PepScreenSizeType;
+    displayText: string;
+    constructor(layoutService: PepLayoutService);
+    private setChildrenParent;
+    private setItemsParent;
+    private updateText;
+    ngOnChanges(changes: any): void;
+    ngOnDestroy(): void;
+    onMenuClicked(event: any): void;
+    onMenuItemClicked(click: IPepMenuItemClickEvent): void;
+    animationDone(): void;
+    animationStart(): void;
+    onMenuOpened(): void;
+    onMenuClosed(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PepMenuComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PepMenuComponent, "pep-menu", never, { "text": "text"; "iconName": "iconName"; "type": "type"; "styleType": "styleType"; "sizeType": "sizeType"; "classNames": "classNames"; "xPosition": "xPosition"; "hideOnEmptyItems": "hideOnEmptyItems"; "items": "items"; "selectedItem": "selectedItem"; "disabled": "disabled"; }, { "stateChange": "stateChange"; "menuItemClick": "menuItemClick"; "menuClick": "menuClick"; }, never, never, false>;
+}

package/menu/menu.model.d.ts

@@ -0,0 +1,25 @@
+export declare type PepMenuType = 'action' | 'action-select' | 'select';
+export declare type PepMenuItemType = 'regular' | 'splitter';
+export declare type PepMenuStateType = 'visible' | 'hidden';
+export declare class PepMenuItemParent {
+    key: string;
+    parent?: PepMenuItemParent;
+    constructor(data: PepMenuItem);
+}
+export declare class PepMenuItem {
+    key: string;
+    text?: string;
+    disabled?: boolean;
+    hidden?: boolean;
+    iconName?: string;
+    type?: PepMenuItemType;
+    children?: Array<PepMenuItem>;
+    parent?: PepMenuItemParent;
+    constructor(data: Partial<PepMenuItem>);
+}
+export interface IPepMenuItemClickEvent {
+    source: PepMenuItem;
+}
+export interface IPepMenuStateChangeEvent {
+    state: PepMenuStateType;
+}

package/menu/menu.module.d.ts

@@ -0,0 +1,18 @@
+import { PepIconRegistry } from '@pepperi-addons/ngx-lib/icon';
+import * as i0 from "@angular/core";
+import * as i1 from "./menu.component";
+import * as i2 from "./menu-item.component";
+import * as i3 from "@angular/common";
+import * as i4 from "@angular/material/core";
+import * as i5 from "@angular/material/form-field";
+import * as i6 from "@angular/material/menu";
+import * as i7 from "@angular/material/icon";
+import * as i8 from "@pepperi-addons/ngx-lib";
+import * as i9 from "@pepperi-addons/ngx-lib/icon";
+export declare class PepMenuModule {
+    private pepIconRegistry;
+    constructor(pepIconRegistry: PepIconRegistry);
+    static ɵfac: i0.ɵɵFactoryDeclaration<PepMenuModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<PepMenuModule, [typeof i1.PepMenuComponent, typeof i2.PepMenuItemComponent], [typeof i3.CommonModule, typeof i4.MatCommonModule, typeof i5.MatFormFieldModule, typeof i6.MatMenuModule, typeof i7.MatIconModule, typeof i8.PepNgxLibModule, typeof i9.PepIconModule], [typeof i1.PepMenuComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<PepMenuModule>;
+}

package/menu/public-api.d.ts

@@ -0,0 +1,3 @@
+export * from './menu.module';
+export * from './menu.model';
+export * from './menu.component';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pepperi-addons/ngx-lib",
-  "version": "0.4.2-beta.137",
+  "version": "0.4.2-beta.139",
   "peerDependencies": {
     "@angular/animations": ">= 14.0.2",
     "@angular/cdk": ">= 14.0.2",

package/page-layout/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+/// <amd-module name="@pepperi-addons/ngx-lib/page-layout" />
+export * from './public-api';