@coolon/angular-ui-powerups 16.1.0-aplpha.16 → 16.1.0-aplpha.161

package/lib/components/tables/column/selection-column-model.d.ts

@@ -1,11 +1,16 @@
 import { ThemePalette } from "@angular/material/core";
-import { Proxified, SelectionModel } from "@coolon/pectin";
+import { GarbageCollector, SelectionModel } from "@coolon/pectin";
 import { ColumnModel } from "./column-model";
-export declare class SelectionColumnModel<Row> extends ColumnModel<Row> {
-    readonly selectionModel: Proxified<SelectionModel<Row>>;
+import { ColumnOrderManager } from "./column-order-manager";
+export declare class SelectionColumnModel<Row extends object> extends ColumnModel<Row> {
     private _enableHeaderControls;
     private _color;
-    constructor(columnId: string, defaults: ColumnModel.TextPropertiesProvider, selectionModel: Proxified<SelectionModel<Row>>);
+    private readonly _selectionModelProxy;
+    private _isUsingTemporarySelection$;
+    private _userSelectionModel;
+    constructor(columnId: string, order: ColumnOrderManager, defaults: ColumnModel.TextPropertiesProvider);
+    get selectionModel(): SelectionModel<Row>;
+    get isUsingTemporarySelectionModel$(): import("@coolon/pectin").ValueModel<boolean>;
     useSelectionModel(selectionModel: SelectionModel<Row>): void;
     protected getDefaultHeaderText(): string;
     enableHeaderControls(enable: boolean): this;
@@ -15,4 +20,5 @@ export declare class SelectionColumnModel<Row> extends ColumnModel<Row> {
     color(color: ThemePalette): void;
     selectRow(row: Row): void;
     isSelected(row: Row): boolean;
+    withTemporarySelectionModel<S extends SelectionModel<Row>>(createSelectionModel: (garbage: GarbageCollector) => S, process: (selectionModel: S) => Promise<void>): Promise<void>;
 }

package/lib/components/tables/editor/edit-row-controls/edit-row-controls.component.d.ts

@@ -2,7 +2,7 @@ import { Command, DirtyTrackingForm } from '@coolon/pectin';
 import { DisposableComponent } from '../../../disposable-component';
 import { EditSession } from '../edit-session';
 import * as i0 from "@angular/core";
-export declare class EditRowControlsComponent<Row> extends DisposableComponent {
+export declare class EditRowControlsComponent<Row extends object> extends DisposableComponent {
     row: Row;
     accessor editRowCommand: Command<void>;
     private _session;

package/lib/components/tables/editor/edit-session.d.ts

@@ -1,5 +1,5 @@
 import { Command, DirtyTrackingForm, GarbageCollector } from '@coolon/pectin';
-export declare class EditSession<Row> extends GarbageCollector {
+export declare class EditSession<Row extends object> extends GarbageCollector {
     readonly rowId: any;
     readonly form: DirtyTrackingForm<Row>;
     readonly saveCommand: Command<boolean | Promise<boolean>>;

package/lib/components/tables/filter/text-search-predicate.d.ts

@@ -1 +1,10 @@
+import { AbstractConstructable } from "@coolon/restilence-plugin";
 export type TextSearchPredicate<Row> = (row: Row, regex: RegExp) => boolean;
+export declare class TextSearchContext<Row> {
+    readonly row: Row;
+    readonly searchText: string;
+    readonly searchRegex: RegExp;
+    constructor(row: Row, searchText: string, searchRegex: RegExp);
+    getOrCreate<T>(type: AbstractConstructable<T>, create: () => T): void;
+    matchesText(text: string): boolean;
+}

package/lib/components/tables/footer/footer-row-model.d.ts

@@ -0,0 +1,22 @@
+import { ComponentType } from "@angular/cdk/overlay";
+import { ComponentPortal } from "@angular/cdk/portal";
+declare class RowClass {
+    readonly className: string;
+    readonly matches: () => boolean;
+    constructor(className: string, matches: () => boolean);
+}
+export declare abstract class FooterRowModel<C> {
+    protected readonly _rowClasses: RowClass[];
+    noPadding(): void;
+    addClass(className: string, condition?: () => boolean): void;
+}
+export declare namespace FooterRowModel {
+    class Impl<C> extends FooterRowModel<C> {
+        protected readonly component: ComponentType<C>;
+        readonly onInit?: (component: C) => void;
+        readonly portal: ComponentPortal<C>;
+        constructor(component: ComponentType<C>, onInit?: (component: C) => void);
+        getActiveRowClasses(): string;
+    }
+}
+export {};

package/lib/components/tables/renderer/abstract-cell-renderer.d.ts

@@ -0,0 +1,6 @@
+import { LoadableComponent } from "../../loadable-component";
+import { CellRenderer } from "./cell-renderer";
+export declare abstract class AbstractCellRenderer<T> extends LoadableComponent implements CellRenderer<T> {
+    abstract accessor value: T;
+    protected constructor();
+}

package/lib/components/tables/renderer/cell-portal-ref.d.ts

@@ -1,52 +1,60 @@
 import { ComponentType } from '@angular/cdk/overlay';
-import { TemplateRef, ViewContainerRef } from '@angular/core';
+import { Host, TemplateRef, ViewContainerRef } from '@angular/core';
 import { ColumnModel, RowData } from '../column/column-model';
 import { EditSession } from '../editor/edit-session';
 import { TableCellComponent } from './table-cell/table-cell.component';
 import { TableHeaderCellComponent } from './table-header-cell/table-header-cell.component';
 export declare const HEADER_CELL_RENDERER_PORTAL: unique symbol;
+export declare const FOOTER_CELL_RENDERER_PORTAL: unique symbol;
 export declare const CELL_RENDERER_PORTAL: unique symbol;
 export declare const CELL_EDITOR_PORTAL: unique symbol;
 export declare const PORTAL_RENDERER_COMPONENT: unique symbol;
 export declare const PORTAL_EDITOR_COMPONENT: unique symbol;
-export declare abstract class CellPortalRef<Row, Host, Portal> {
-    abstract initialiseHost(host: Host, columnModel: ColumnModel<Row>): void;
+export declare abstract class CellPortalRef<Row extends object, Host, Portal> {
+    abstract initialiseHost(host: Host): void;
     abstract onPortalAttached(host: Host, portalComponent: Portal): void;
 }
-export declare class CellHeaderPortalRef<Row, C> extends CellPortalRef<Row, TableHeaderCellComponent, C> {
+export declare class CellHeaderPortalRef<Row extends object, C> extends CellPortalRef<Row, TableHeaderCellComponent, C> {
     readonly componentType: ComponentType<C>;
     readonly initialiseHeader: (component: C, columnModel: ColumnModel<Row>) => void;
     constructor(componentType: ComponentType<C>, initialiseHeader: (component: C, columnModel: ColumnModel<Row>) => void);
-    initialiseHost(host: TableHeaderCellComponent, columnModel: ColumnModel<Row>): void;
+    initialiseHost(host: Host): void;
     onPortalAttached(host: TableHeaderCellComponent, portalComponent: C): void;
 }
-export declare abstract class CellRendererPortalRef<Row, Portal> extends CellPortalRef<Row, TableCellComponent<Row>, Portal> {
+export declare abstract class CellRendererPortalRef<Row extends object, Portal> extends CellPortalRef<Row, TableCellComponent<Row>, Portal> {
     abstract pushState(host: TableCellComponent<Row>): void;
 }
-export declare class ComponentCellRendererPortalRef<Row, Portal> extends CellRendererPortalRef<Row, Portal> {
+export declare class ComponentCellRendererPortalRef<Row extends object, Portal> extends CellRendererPortalRef<Row, Portal> {
     readonly componentType: ComponentType<Portal>;
     readonly updateComponent: (component: Portal, rowData: RowData<Row>, firstTime: boolean) => void;
     constructor(componentType: ComponentType<Portal>, updateComponent: (component: Portal, rowData: RowData<Row>, firstTime: boolean) => void);
-    initialiseHost(host: TableCellComponent<Row>, columnModel: ColumnModel<Row>): void;
+    initialiseHost(host: Host): void;
     onPortalAttached(host: TableCellComponent<Row>, portalComponent: Portal): void;
     pushState(host: TableCellComponent<Row>): void;
 }
-export declare class CellEditorPortalRef<Row, Portal> extends CellPortalRef<Row, TableCellComponent<Row>, Portal> {
+export declare class CellEditorPortalRef<Row extends object, Portal> extends CellPortalRef<Row, TableCellComponent<Row>, Portal> {
     readonly componentType: ComponentType<Portal>;
     readonly initialiseEditorSession: (component: Portal, editSession: EditSession<Row>) => void;
     constructor(componentType: ComponentType<Portal>, initialiseEditorSession: (component: Portal, editSession: EditSession<Row>) => void);
-    initialiseHost(host: TableCellComponent<Row>, columnModel: ColumnModel<Row>): void;
+    initialiseHost(host: Host): void;
     onPortalAttached(host: TableCellComponent<Row>, portalComponent: Portal): void;
 }
-export declare class TemplateCellRendererPortalRef<Row> extends CellRendererPortalRef<Row, undefined> {
+export declare class TemplateCellRendererPortalRef<Row extends object> extends CellRendererPortalRef<Row, undefined> {
     private templateRef;
     private viewContainer;
     private fillCell;
     private padChild;
     constructor();
     registerPortal(templateRef: TemplateRef<any>, viewContainer: ViewContainerRef, fillCell: boolean, padChild: boolean): void;
-    initialiseHost(host: TableCellComponent<Row>, columnModel: ColumnModel<Row>): void;
+    initialiseHost(host: Host): void;
     onPortalAttached(host: TableCellComponent<Row>, portalComponent: undefined): void;
     pushState(host: TableCellComponent<Row>): void;
     private createPortal;
 }
+export declare class CellFooterPortalRef<Row extends object, C> extends CellPortalRef<Row, TableHeaderCellComponent, C> {
+    readonly componentType: ComponentType<C>;
+    readonly initialiseHeader: (component: C, columnModel: ColumnModel<Row>) => void;
+    constructor(componentType: ComponentType<C>, initialiseHeader: (component: C, columnModel: ColumnModel<Row>) => void);
+    initialiseHost(host: Host): void;
+    onPortalAttached(host: TableHeaderCellComponent, portalComponent: C): void;
+}

package/lib/components/tables/renderer/select-header-cell/selection-header-cell.component.d.ts

@@ -1,4 +1,4 @@
-import { ThemePalette } from "@angular/material/core";
+import { ThemePalette } from '@angular/material/core';
 import { Command, MultipleSelectionModel, SelectionModel } from '@coolon/pectin';
 import { DisposableComponent } from '../../../disposable-component';
 import * as i0 from "@angular/core";

package/lib/components/tables/renderer/table-action-column/menu-builder.d.ts

@@ -0,0 +1,7 @@
+import { Command, CommandFace } from '@coolon/pectin';
+import { FileDownloadComponent } from '../../../file/file-download/file-download.component';
+export interface MenuBuilder<Row extends object> {
+    addCommand(factory: Command.Factory<Row>, face: CommandFace): void;
+    addDownload(callback: (row: Row) => FileDownloadComponent.DownloadInfo): void;
+    addSeparator(): void;
+}

package/lib/components/tables/renderer/table-action-column/table-action-column.component.d.ts

@@ -0,0 +1,42 @@
+import { MatMenuTrigger } from '@angular/material/menu';
+import { Command } from '@coolon/pectin';
+import { CommandFace } from '../../../commands/command-face';
+import { DisposableComponent } from '../../../disposable-component';
+import { FileDownloadComponent } from '../../../file/file-download/file-download.component';
+import { CellRenderer } from '../cell-renderer';
+import { MenuBuilder } from './menu-builder';
+import * as i0 from "@angular/core";
+declare class CommandData<T extends object> {
+    readonly factory: Command.Factory<T, void>;
+    readonly face: CommandFace;
+    constructor(factory: Command.Factory<T, void>, face: CommandFace);
+}
+declare class DownloadData<T extends object> {
+    private createInfo;
+    private cache;
+    constructor(createInfo: (value: T) => FileDownloadComponent.DownloadInfo);
+    createDownloadInfo(value: T): FileDownloadComponent.DownloadInfo;
+}
+type MenuItem<T extends object> = CommandData<T> | DownloadData<T> | null;
+/**
+ *
+ */
+export declare class TableActionColumnComponent<T extends object> extends DisposableComponent implements CellRenderer<T>, MenuBuilder<T> {
+    value: T;
+    menu: MatMenuTrigger;
+    readonly actions: MenuItem<T>[];
+    readonly moreActions: MenuItem<T>[];
+    readonly trackByIndex: import("@angular/core").TrackByFunction<any>;
+    constructor();
+    addCommand(commandFactory: Command.Factory<T, void>, properties: CommandFace): void;
+    addSeparator(): void;
+    addDownload(factory: (row: T) => FileDownloadComponent.DownloadInfo): void;
+    addMoreMenu(builder: (menu: MenuBuilder<T>) => void): void;
+    private closeMoreMenu;
+    isCommand(item: MenuItem<T>): item is CommandData<T>;
+    isDownload(item: MenuItem<T>): item is DownloadData<T>;
+    isSeparator(item: MenuItem<T>): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableActionColumnComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TableActionColumnComponent<any>, "aup-table-action-column", never, { "value": { "alias": "value"; "required": false; }; }, {}, never, never, false, never>;
+}
+export {};

package/lib/components/tables/renderer/table-body/table-body.component.d.ts

@@ -1,36 +1,60 @@
-import { ElementRef, EventEmitter, NgZone, OnInit } from "@angular/core";
-import { ListModel, ListModelChain, ValueModel } from "@coolon/pectin";
+import { CdkPortalOutletAttachedRef } from "@angular/cdk/portal";
+import { CdkVirtualScrollViewport } from "@angular/cdk/scrolling";
+import { AfterViewInit, ElementRef, InjectionToken, OnInit } from "@angular/core";
+import { ListModel, ListModelChain, MutableValueModel, Proxify, ValueModel } from "@coolon/pectin";
+import { TableVirtualScrollDataSource } from "ng-table-virtual-scroll";
 import { ResizeAwareComponent } from "../../../resize-aware.component";
 import { AbstractTableModel } from "../../abstract-table-model";
 import { ColumnModel } from "../../column/column-model";
+import { FooterRowModel } from "../../footer/footer-row-model";
 import * as i0 from "@angular/core";
-export declare class TableBodyComponent<Row> extends ResizeAwareComponent implements OnInit {
+export declare const AUP_TABLE_VIRTUAL_SCROLL_BUFFER_MULTIPLIER: InjectionToken<number>;
+export declare class TableRowAttributesDirective implements OnInit {
+    protected readonly elementRef: ElementRef<HTMLElement>;
+    aupTableRowAttributes: Record<string, string>;
+    constructor(elementRef: ElementRef<HTMLElement>);
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableRowAttributesDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TableRowAttributesDirective, "[aupTableRowAttributes]", never, { "aupTableRowAttributes": { "alias": "aupTableRowAttributes"; "required": false; }; }, {}, never, never, false, never>;
+}
+export declare class TableBodyComponent<Row extends object> extends ResizeAwareComponent implements AfterViewInit {
+    protected bufferMultiplier: number;
     accessor data$: ListModel<Row>;
     accessor tableModel: AbstractTableModel<Row>;
+    accessor footerRow: FooterRowModel.Impl<any>;
     accessor showHeader$: ValueModel<boolean>;
     accessor showHeader: boolean;
-    readonly visibleRowCount: EventEmitter<number>;
     trackBy: (index: number, item: Row) => any;
-    /**
-     * Set to true to enable scrolling.  Once enabled the table will have 0 implicit height.  You will either
-     * need to set it explicitly e.g. height: 400px; or by using flex or grid layout to make it fill it's
-     * containment area.
-     */
-    enableScrolling: boolean;
+    accessor scrollMode$: ValueModel<TableBodyComponent.ScrollMode>;
+    accessor scrollMode: TableBodyComponent.ScrollMode;
+    scrollViewport: CdkVirtualScrollViewport;
     columns$: ListModelChain<ColumnModel<Row>>;
     columnIds$: ListModelChain<string>;
     private columnsById$;
-    readonly _visibleRowCount$: ValueModel<number>;
-    private readonly headerHeight$;
-    private readonly rowHeight$;
+    protected readonly headerHeight$: MutableValueModel<number>;
+    protected rowHeight$: MutableValueModel<number>;
     baseCssClass: string;
-    constructor(elementRef: ElementRef, ngZone: NgZone);
+    protected virtualScrollDataSource: TableVirtualScrollDataSource<Row>;
+    private virtualScrollActive$;
+    private scrollTimeout;
+    constructor(bufferMultiplier?: number);
+    ngAfterViewInit(): void;
     get hideHeader(): boolean;
+    get headerHeightCssVar(): string;
+    get rowHeightCssVar(): string;
     isEditing(row: Row): boolean;
     notifyCellClicked(columnModel: ColumnModel<Row>, row: Row): void;
     isFirstVisibleColumn(columnId: string): boolean;
     isLastVisibleColumn(columnId: string): boolean;
     getColumnClasses(columnId: string): string[];
-    static ɵfac: i0.ɵɵFactoryDeclaration<TableBodyComponent<any>, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<TableBodyComponent<any>, "aup-table-body", never, { "data$": { "alias": "data$"; "required": false; }; "tableModel": { "alias": "tableModel"; "required": false; }; "showHeader$": { "alias": "showHeader$"; "required": false; }; "showHeader": { "alias": "showHeader"; "required": false; }; "trackBy": { "alias": "trackBy"; "required": false; }; "enableScrolling": { "alias": "enableScrolling"; "required": false; }; }, { "visibleRowCount": "visibleRowCount"; }, never, never, false, never>;
+    private scheduleTableHeightCheck;
+    private notifyScrolled;
+    private clearScrollTimeout;
+    initialiseFooter($event: CdkPortalOutletAttachedRef): void;
+    protected readonly Proxify: typeof Proxify;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableBodyComponent<any>, [{ optional: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TableBodyComponent<any>, "aup-table-body", never, { "data$": { "alias": "data$"; "required": false; }; "tableModel": { "alias": "tableModel"; "required": false; }; "footerRow": { "alias": "footerRow"; "required": false; }; "showHeader$": { "alias": "showHeader$"; "required": false; }; "showHeader": { "alias": "showHeader"; "required": false; }; "trackBy": { "alias": "trackBy"; "required": false; }; "scrollMode$": { "alias": "scrollMode$"; "required": false; }; "scrollMode": { "alias": "scrollMode"; "required": false; }; }, {}, never, never, false, never>;
+}
+export declare namespace TableBodyComponent {
+    type ScrollMode = "none" | "classic" | "virtual";
 }

package/lib/components/tables/renderer/table-cell/table-cell.component.d.ts

@@ -6,18 +6,17 @@ import { ColumnModel, RowData } from "../../column/column-model";
 import { EditSession } from "../../editor/edit-session";
 import { CELL_EDITOR_PORTAL, CELL_RENDERER_PORTAL } from "../cell-portal-ref";
 import * as i0 from "@angular/core";
-export declare class TableCellComponent<Row> extends DisposableComponent implements OnChanges {
+export declare class TableCellComponent<Row extends object> extends DisposableComponent implements OnChanges {
     row: Row;
     column: ColumnModel<Row>;
     editSession: EditSession<Row>;
     tableModel: AbstractTableModel<Row>;
-    private editRowCommand;
+    private readonly editRowCommand;
     [CELL_RENDERER_PORTAL]: Portal<any>;
     [CELL_EDITOR_PORTAL]: Portal<any>;
     defaultClassNames: string;
     fillCell: boolean;
     padChild: boolean;
-    private firstEditableColumn;
     constructor();
     hasActiveEditor(): boolean;
     initialiseRenderer(ref: CdkPortalOutletAttachedRef): void;

package/lib/components/tables/renderer/table-custom-more-menu/table-custom-more-menu-popup.component.d.ts

@@ -0,0 +1,19 @@
+import { Command, ValueModel } from "@coolon/pectin";
+import { PopupAwareComponent } from "../../../commands/group/popup-aware.component";
+import { PopupContainer } from "../../../commands/group/popup-container";
+import { LoadableComponent } from "../../../loadable-component";
+import * as i0 from "@angular/core";
+export declare class TableCustomMoreMenuPopupComponent<T> extends LoadableComponent implements PopupContainer {
+    private _value$;
+    private readonly _visible$;
+    private readonly _closeCommand;
+    constructor();
+    initialise(row$: ValueModel<T>, closeCommand: Command<void>): void;
+    protected visibleWhile(condition: ValueModel<boolean>): this;
+    get visible$(): ValueModel<boolean>;
+    get closeCommand(): Command<void>;
+    get value$(): ValueModel<T>;
+    register(comp: PopupAwareComponent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableCustomMoreMenuPopupComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TableCustomMoreMenuPopupComponent<any>, "aup-table-more-menu-popup", never, {}, {}, never, never, false, never>;
+}

package/lib/components/tables/renderer/{table-more-menu/table-more-menu.component.d.ts → table-custom-more-menu/table-custom-more-menu.component.d.ts}

@@ -1,23 +1,24 @@
 import { CdkPortalOutletAttachedRef, ComponentPortal } from "@angular/cdk/portal";
 import { MatMenuTrigger } from "@angular/material/menu";
-import { ValueModelChain } from "@coolon/pectin";
+import { ValueModelChain } from '@coolon/pectin';
 import { Constructable } from "@coolon/typescript-utilities";
 import { DisposableComponent } from "../../../disposable-component";
 import { CellRenderer } from "../cell-renderer";
-import { TableMoreMenuPopupComponent } from "./table-more-menu-popup/table-more-menu-popup.component";
+import { TableCustomMoreMenuPopupComponent } from "./table-custom-more-menu-popup.component";
 import * as i0 from "@angular/core";
-export declare class TableMoreMenuComponent<T> extends DisposableComponent implements CellRenderer<T> {
+export declare class TableCustomMoreMenuComponent<T> extends DisposableComponent implements CellRenderer<T> {
     private value$;
     accessor value: T;
     matMenuTrigger: MatMenuTrigger;
     private readonly popupType$;
-    popupComponentPortal$: ValueModelChain<ComponentPortal<TableMoreMenuPopupComponent<T>>>;
+    popupComponentPortal$: ValueModelChain<ComponentPortal<TableCustomMoreMenuPopupComponent<T>>>;
     private readonly _visible$;
+    private initialiseCallback?;
     constructor();
-    configurePopupComponentType(popupComponentType: Constructable<TableMoreMenuPopupComponent<T>>): void;
+    configurePopupComponentType(popupComponentType: Constructable<TableCustomMoreMenuPopupComponent<T>>, configureCallback?: (component: TableCustomMoreMenuPopupComponent<T>) => void): void;
     preventDefault($event: MouseEvent): void;
     initialise($event: CdkPortalOutletAttachedRef): void;
     get visible$(): import("@coolon/pectin").ValueModel<boolean>;
-    static ɵfac: i0.ɵɵFactoryDeclaration<TableMoreMenuComponent<any>, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<TableMoreMenuComponent<any>, "aup-table-more-menu", never, {}, {}, never, never, false, never>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableCustomMoreMenuComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TableCustomMoreMenuComponent<any>, "aup-table-custom-more-menu", never, {}, {}, never, never, false, never>;
 }

package/lib/components/tables/renderer/table-footer-row/table-footer-row.component.d.ts

@@ -0,0 +1,11 @@
+import { CdkPortalOutletAttachedRef } from "@angular/cdk/portal";
+import { FooterRowModel } from "../../footer/footer-row-model";
+import * as i0 from "@angular/core";
+export declare class TableFooterRow {
+    row: FooterRowModel.Impl<any>;
+    defaultClassNames: string;
+    get rowClasses(): string;
+    initialise($event: CdkPortalOutletAttachedRef): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableFooterRow, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TableFooterRow, "aup-table-footer-row", never, { "row": { "alias": "row"; "required": false; }; }, {}, never, never, false, never>;
+}

package/lib/components/tables/table/table-model.d.ts

@@ -1,6 +1,5 @@
-import { ListModel, SelectionModel, ValueModel } from "@coolon/pectin";
+import { ListModel, MultipleSelectionModel, ValueModel } from "@coolon/pectin";
 import { AbstractTableModel } from "../abstract-table-model";
-import { SelectionColumnModel } from "../column/selection-column-model";
 /**
  * Example:
  * @example
@@ -80,8 +79,9 @@ import { SelectionColumnModel } from "../column/selection-column-model";
  *   table.columnTextProperties(I18n.table.columns); // <- configures all columns
  * });
  */
-export declare class TableModel<Row> extends AbstractTableModel<Row> {
+export declare class TableModel<Row extends object> extends AbstractTableModel<Row> {
     constructor(sourceOfTruth?: ListModel<Row>, builder?: (table: TableModel<Row>) => void);
     bindToTable(filteredRows$: ListModel<Row>, visibleRows$: ListModel<Row>): void;
-    addSelectionColumn(selectionModel?: SelectionModel<Row>, showSelectionColumn?: ValueModel<boolean> | boolean): SelectionColumnModel<Row>;
+    get isUsingTemporarySelectionModel$(): ValueModel<boolean>;
+    withTemporaryMultipleSelectionModel(process: (selectionModel: MultipleSelectionModel<Row, any>) => Promise<void>): Promise<void>;
 }

package/lib/components/tables/table/table.component.d.ts

@@ -3,6 +3,7 @@ import { ValueModel } from "@coolon/pectin";
 import { AbstractTableModel } from '../abstract-table-model';
 import { AbstractTableComponent } from '../abstract-table.component';
 import { TableFilterModel } from "../filter/table-filter-model";
+import { TableBodyComponent } from "../renderer/table-body/table-body.component";
 import { TableModel } from "./table-model";
 import * as i0 from "@angular/core";
 /**
@@ -65,23 +66,26 @@ import * as i0 from "@angular/core";
  *   }
  * }
  */
-export declare class TableComponent<Row> extends AbstractTableComponent<Row> implements OnInit {
+export declare class TableComponent<Row extends object> extends AbstractTableComponent<Row> implements OnInit {
     accessor tableModel: TableModel<Row>;
     accessor filterModel: TableFilterModel<Row>;
-    accessor enablePaging$: ValueModel<boolean>;
-    accessor enablePaging: boolean;
+    tableBody: TableBodyComponent<Row>;
+    /**
+     * Set to true to scroll mode to classic or virtual (default).  Virtual scrolll performs better for large data sets but clamps the row height.  Classic scroll
+     * renders all rows but allows row heights to grow.
+     */
+    accessor scrollMode$: ValueModel<TableComponent.ScrollMode>;
+    accessor scrollMode: TableComponent.ScrollMode;
     private _footerContentAdded;
     private readonly _filteredRows$;
-    private _pageSize;
-    private pagedListModel;
+    protected readonly tableBodyScrollMode$: ValueModel<TableBodyComponent.ScrollMode>;
     constructor(injector: Injector);
     ngOnInit(): void;
     protected getModel(): AbstractTableModel<Row>;
-    get pageController(): import("@coolon/pectin").PageController;
-    private configurePaging;
-    private disposeOfPagedListModel;
     footerContentChanged($event: any): void;
-    updatePageSize(count: number): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<TableComponent<any>, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<TableComponent<any>, "aup-table", never, { "tableModel": { "alias": "tableModel"; "required": false; }; "filterModel": { "alias": "filterModel"; "required": false; }; "enablePaging$": { "alias": "enablePaging$"; "required": false; }; "enablePaging": { "alias": "enablePaging"; "required": false; }; }, {}, never, ["[footer]"], false, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TableComponent<any>, "aup-table", never, { "tableModel": { "alias": "tableModel"; "required": false; }; "filterModel": { "alias": "filterModel"; "required": false; }; "scrollMode$": { "alias": "scrollMode$"; "required": false; }; "scrollMode": { "alias": "scrollMode"; "required": false; }; }, {}, never, ["[footer], [slot=footer]"], false, never>;
+}
+export declare namespace TableComponent {
+    type ScrollMode = Omit<TableBodyComponent.ScrollMode, 'none'>;
 }

package/lib/components/tables/tree-table/tree-label-cell-renderer/tree-label-cell-renderer.component.d.ts

@@ -5,7 +5,7 @@ import { CellRenderer } from '../../renderer/cell-renderer';
 import { TreeInheritanceIconComponent } from '../tree-inheritance-icon/tree-inheritance-icon.component';
 import { TreeTableModel } from '../tree-table-model';
 import * as i0 from "@angular/core";
-export declare class TreeLabelCellRendererComponent<T> extends DisposableComponent implements CellRenderer<T>, OnInit {
+export declare class TreeLabelCellRendererComponent<T extends object> extends DisposableComponent implements CellRenderer<T>, OnInit {
     private node$;
     accessor value: T;
     label: string;

package/lib/components/tables/tree-table/tree-label-column-model.d.ts

@@ -1,13 +1,14 @@
 import { ComponentType } from '@angular/cdk/overlay';
 import { Types } from '@coolon/pectin';
 import { ColumnModel } from '../column/column-model';
+import { ColumnOrderManager } from "../column/column-order-manager";
 import { TreeLabelCellRendererComponent } from './tree-label-cell-renderer/tree-label-cell-renderer.component';
 import { TreeTableModel } from './tree-table-model';
-export declare class TreeLabelColumnModel<Row> extends ColumnModel<Row> {
+export declare class TreeLabelColumnModel<Row extends object> extends ColumnModel<Row> {
     readonly expansionModel: TreeTableModel<Row>;
     private labelFactory;
     private iconFactory;
-    constructor(columnId: string, textPropertiesProvider: ColumnModel.TextPropertiesProvider, expansionModel: TreeTableModel<Row>);
+    constructor(columnId: string, order: ColumnOrderManager, textPropertiesProvider: ColumnModel.TextPropertiesProvider, expansionModel: TreeTableModel<Row>);
     pluck<P extends Types.StringValuePropertiesOf<Row>>(property: P): void;
     useLabel(factory: (row: Row) => string): void;
     /**

package/lib/components/tables/tree-table/tree-table-component.d.ts

@@ -1,7 +1,9 @@
 import { Injector, OnInit } from "@angular/core";
+import { ValueModel } from '@coolon/pectin';
 import { TreeNode } from '@coolon/typescript-utilities';
 import { AbstractTableModel } from '../abstract-table-model';
 import { AbstractTableComponent } from '../abstract-table.component';
+import { TableBodyComponent } from "../renderer/table-body/table-body.component";
 import { TreeExpansionModel } from "./tree-expansion-model";
 import { TreeTableModel } from './tree-table-model';
 import * as i0 from "@angular/core";
@@ -68,6 +70,7 @@ import * as i0 from "@angular/core";
 export declare class TreeTableComponent<T extends TreeNode<T>> extends AbstractTableComponent<T> implements OnInit {
     accessor treeTableModel: TreeTableModel<T>;
     accessor expansionModel: TreeExpansionModel<T>;
+    protected readonly scrollMode$: ValueModel<TableBodyComponent.ScrollMode>;
     constructor(injector: Injector);
     ngOnInit(): void;
     getModel(): AbstractTableModel<T>;

package/lib/components/tables/tree-table/tree-table-model.d.ts

@@ -1,26 +1,25 @@
-import { ListModel, MutableValueModel, SelectionModel, ValueModel } from '@coolon/pectin';
+import { ChangeDetectorRef } from "@angular/core";
+import { ListModel, MutableValueModel, ValueModel } from '@coolon/pectin';
 import { AbstractTableModel } from '../abstract-table-model';
-import { SelectionColumnModel } from "../column/selection-column-model";
 import { TreeExpansionModel } from './tree-expansion-model';
 import { TreeLabelColumnModel } from './tree-label-column-model';
 export type ChildArrayPropertiesOf<T> = {
     [K in keyof T]: T[K] extends T[] ? K : never;
 }[keyof T];
-export declare class TreeTableModel<Row> extends AbstractTableModel<Row> {
+export declare class TreeTableModel<Row extends object> extends AbstractTableModel<Row> {
     private treeExpansionModel;
     private readonly flattenedDataSource;
     readonly childExtractor: (row: Row) => Row[];
     private _isExpandedPredicate$;
     constructor(source$: ListModel<Row>, childAccessor: ChildArrayPropertiesOf<Row> | ((node: Row) => Row[]), builder?: (model: TreeTableModel<Row>) => void);
     get isExpandedPredicate$(): ValueModel<(node: Row) => boolean>;
-    bindToTable(expansionModel: TreeExpansionModel<Row>, filteredRows$: ListModel<Row>, visibleRows$: ListModel<Row>): void;
+    bindToTable(expansionModel: TreeExpansionModel<Row>, filteredRows$: ListModel<Row>, visibleRows$: ListModel<Row>, cdr: ChangeDetectorRef): void;
     treeControlColumn(builder: (column: TreeLabelColumnModel<Row>) => void): void;
     expand(node: Row): void;
     collapse(node: Row): void;
     isCollapsed(node: Row): boolean;
     ensureAncestorsAndSelfVisible(node: Row): void;
     isExpanded(row: Row): boolean;
-    addSelectionColumn(selectionModel?: SelectionModel<Row>, showSelectionColumn?: ValueModel<boolean> | boolean): SelectionColumnModel<Row>;
 }
 export declare namespace TreeTableModel {
     interface Options<T, K extends keyof T> {

package/lib/directives/command.directive.d.ts

@@ -1,6 +1,6 @@
 import { AfterViewInit, ElementRef, OnDestroy, OnInit } from '@angular/core';
 import { MatButton } from '@angular/material/button';
-import { MatMenuItem } from '@angular/material/menu';
+import { MatMenu, MatMenuItem } from '@angular/material/menu';
 import { Command, GarbageCollector, UnaryCommand } from '@coolon/pectin';
 import * as i0 from "@angular/core";
 export declare class CommandDirective<P = any> extends GarbageCollector implements OnInit, OnDestroy, AfterViewInit {
@@ -8,18 +8,20 @@ export declare class CommandDirective<P = any> extends GarbageCollector implemen
     private _command;
     private _commandEnabled;
     private matControl;
+    private isInPopupMenu;
     set pectinCommand(command: Command<any> | UnaryCommand<P>);
     get pectinCommand(): Command<any> | UnaryCommand<P>;
     private _commandParameter;
     private _commandParameterProvided;
     set commandParameter(value: P);
     get commandParameter(): P;
-    constructor(elementRef: ElementRef, matButton: MatButton, matMenuItem: MatMenuItem);
+    preventDefault: boolean;
+    constructor(elementRef: ElementRef, matButton: MatButton, matMenuItem: MatMenuItem, matMenu?: MatMenu);
     ngOnInit(): void;
     ngAfterViewInit(): void;
     updateEnabledState(enabled: boolean): void;
     ngOnDestroy(): void;
     notifyClick($event: Event): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<CommandDirective<any>, [null, { optional: true; host: true; }, { optional: true; host: true; }]>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<CommandDirective<any>, "[pectinCommand]", never, { "pectinCommand": { "alias": "pectinCommand"; "required": false; }; "commandParameter": { "alias": "commandParameter"; "required": false; }; }, {}, never, never, false, never>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CommandDirective<any>, [null, { optional: true; host: true; }, { optional: true; host: true; }, { optional: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CommandDirective<any>, "[pectinCommand]", never, { "pectinCommand": { "alias": "pectinCommand"; "required": false; }; "commandParameter": { "alias": "commandParameter"; "required": false; }; "preventDefault": { "alias": "preventDefault"; "required": false; }; }, {}, never, never, false, never>;
 }

package/lib/directives/exports.d.ts

@@ -9,3 +9,4 @@ export * from "./focus-binding";
 export * from "./garbage-collector.directive";
 export * from "./highlight-text-model.directive";
 export * from "./highlight.pipe";
+export * from "./resize-observer.directive";

package/lib/directives/resize-observer.directive.d.ts

@@ -0,0 +1,16 @@
+import { AfterViewInit, ElementRef, EventEmitter, NgZone } from '@angular/core';
+import { ValueModel } from '@coolon/pectin';
+import { DisposableComponent } from '../components/disposable-component';
+import { Bounds } from '../components/types/bounds.class';
+import * as i0 from "@angular/core";
+export declare class ResizeObserverDirective extends DisposableComponent implements AfterViewInit {
+    aupOnResize: EventEmitter<Bounds>;
+    protected readonly elementRef: ElementRef<any>;
+    protected readonly ngZone: NgZone;
+    private _bounds$;
+    ngAfterViewInit(): void;
+    get bounds$(): ValueModel<Bounds>;
+    private _updateBounds;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ResizeObserverDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ResizeObserverDirective, "[aupOnResize]", never, {}, { "aupOnResize": "aupOnResize"; }, never, never, true, never>;
+}

package/lib/interaction/abstract-interaction-context.d.ts

@@ -9,7 +9,7 @@ export declare abstract class AbstractInteractionContext implements InteractionC
     abstract dispose(): void;
     abstract registerDisposable<T extends Disposable>(disposable: T): T;
     abstract isActive(): boolean;
-    protected abstract createAndLaunchActivity<D, R, E>(activityType: Constructable<Activity<D, R, E>>, data: D, disableClose: boolean): Promise<R>;
+    protected abstract createAndLaunchActivity<D, R, E>(activityType: Constructable<Activity<D, R, E>>, data: D, options?: InteractionContext.Options): Promise<R>;
     startActivity<D, R, E>(activityType: Constructable<Activity<D, R, E>>, data?: D, options?: InteractionContext.Options): Promise<R>;
     confirm(confirm: Confirm): Promise<boolean>;
     alert(alert: Alert): Promise<void>;

package/lib/interaction/activity-context.d.ts

@@ -0,0 +1,9 @@
+import { Command } from "@coolon/pectin";
+import { InteractionContext } from "./interaction-context";
+import { InteractionContextProvider } from "./interaction-context-provider";
+export declare abstract class ActivityContext extends InteractionContextProvider {
+    abstract readonly interactionContext: InteractionContext;
+    abstract readonly confirmCommand: Command;
+    abstract readonly cancelCommand: Command;
+    abstract onActivityReady(callback: () => void): void;
+}