@coolon/angular-ui-powerups 16.1.0-alpha.238 → 16.1.0-aplpha.0

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

@@ -0,0 +1,13 @@
+import { AbstractComputedListModel, ListModel } from '@coolon/pectin';
+import { ColumnModel } from './column-model';
+export declare class ColumnListModel<Row> extends AbstractComputedListModel<ColumnModel<Row>, boolean> {
+    private readonly _allColumns$;
+    private readonly columnsById$;
+    constructor();
+    get allColumns$(): ListModel<ColumnModel<Row>>;
+    getColumn(id: string): ColumnModel<Row>;
+    hasColumn(id: string): boolean;
+    hasMatchingColumn(row: Row, regex: RegExp): boolean;
+    addColumn<C extends ColumnModel<Row>>(column: C, index?: number): C;
+    doComputeValue(): ColumnModel<Row>[];
+}

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

@@ -1,15 +1,17 @@
 import { ComponentType } from "@angular/cdk/overlay";
 import { CdkPortalOutletAttachedRef } from "@angular/cdk/portal";
 import { Injector } from "@angular/core";
-import { GarbageCollector, ValueModel } from "@coolon/pectin";
+import { Command, GarbageCollector, ValueModel } from "@coolon/pectin";
+import { EditSession } from "../editor/edit-session";
+import { CellEditorPortalRef, CellHeaderPortalRef, CellRendererPortalRef } from "../renderer/cell-portal-ref";
+import { TableCellComponent } from "../renderer/table-cell/table-cell.component";
+import { TableHeaderCellComponent } from "../renderer/table-header-cell/table-header-cell.component";
 import { ColumnTextSearchFormatter } from "../filter/column-text-search-formatter";
-import { CellHeaderPortalRef, type CellRendererPortalRef } from "../renderer/cell-portal-ref";
-import type { TableCellComponent } from "../renderer/table-cell/table-cell.component";
-import type { TableHeaderCellComponent } from "../renderer/table-header-cell/table-header-cell.component";
-import type { ColumnOrderManager } from "./column-order-manager";
-import type { ColumnTextProperties } from "./column-text-properties";
-export interface RowData<Row extends object> {
+import { ColumnTextProperties } from "./column-text-properties";
+export interface RowData<Row> {
     row: Row;
+    editSession?: EditSession<Row>;
+    editRowCommand: Command<void>;
 }
 export type OnComponentInit<C> = (component: C) => void;
 export interface CellRendererOptions<Row, E> {
@@ -19,13 +21,13 @@ export interface CellRendererOptions<Row, E> {
 export interface MutableCellRendererOptions<Row, E, P extends keyof Row> extends CellRendererOptions<Row, E> {
     onValueEdit: (row: Row, is: Row[P], was: Row[P]) => void;
 }
-export declare class ColumnModel<Row extends object> extends GarbageCollector {
+export declare class ColumnModel<Row> extends GarbageCollector {
     readonly columnId: string;
-    private readonly order;
     private textPropertiesProvider;
     private _columnTextProperties;
     private _columnHeaderPortalRef;
     private _cellRendererPortalRef;
+    private _cellEditorPortalRef;
     private _enableRowSelection;
     private _flex;
     private _defaultVisibility$;
@@ -34,7 +36,7 @@ export declare class ColumnModel<Row extends object> extends GarbageCollector {
     readonly dasherisedColumnId: string;
     private readonly textSearchDelegate;
     readonly visible$: ValueModel<boolean>;
-    constructor(columnId: string, order: ColumnOrderManager, textPropertiesProvider: ColumnModel.TextPropertiesProvider);
+    constructor(columnId: string, textPropertiesProvider: ColumnModel.TextPropertiesProvider);
     protected installHeaderRenderer(): void;
     getHeaderText(): string;
     isVisible(): boolean;
@@ -49,20 +51,21 @@ export declare class ColumnModel<Row extends object> extends GarbageCollector {
      */
     textProperties(columnTextProperties: ColumnTextProperties): this;
     columnTextProperties(columnTextProperties: ColumnTextProperties): this;
-    positionAfter(column: ColumnModel<any>): this;
-    positionBefore(column: ColumnModel<any>): this;
     getSearchTextFor(row: Row): string;
     configureColumnTextSearch(formatter: ColumnTextSearchFormatter<Row>): this;
     configureColumnTextSearch<T>(formatter: ColumnTextSearchFormatter<T>, mapper: (row: Row) => T): this;
-    protected configureHeaderRenderer<C>(config: CellHeaderPortalRef<Row, unknown>): void;
-    protected configureCellRenderer<C>(config: CellRendererPortalRef<Row, unknown>): void;
+    protected configureHeaderRenderer<C>(config: CellHeaderPortalRef<Row, any>): void;
+    protected configureCellRenderer<C>(config: CellRendererPortalRef<Row, any>): void;
+    protected configureCellEditor<E>(cellEditor: CellEditorPortalRef<Row, E>): void;
     cellHeaderRenderer<C>(componentType: ComponentType<C>, initialiser: (component: C, column: ColumnModel<Row>) => void): this;
     flex(flex?: boolean): void;
     isFlex(): boolean;
+    hasEditorPortal(): boolean;
     attachHeaderCell(host: any): void;
     attachCell(host: any): void;
     onHeaderAttached(host: TableHeaderCellComponent, ref: CdkPortalOutletAttachedRef): void;
     onRendererAttached(host: TableCellComponent<Row>, ref: CdkPortalOutletAttachedRef): void;
+    onEditorAttached(host: TableCellComponent<Row>, ref: CdkPortalOutletAttachedRef): void;
     updatePortalContent(host: TableCellComponent<Row>): void;
     protected _selectRowOnClick(selectRowOnClick: boolean): this;
     isRowSelectionEnabled(): boolean;

package/lib/components/tables/column/custom-template-column-model.d.ts

@@ -1,9 +1,8 @@
 import { TemplateRef, ViewContainerRef } from "@angular/core";
 import { ColumnModel } from "./column-model";
-import type { ColumnOrderManager } from "./column-order-manager";
-export declare class CustomTemplateColumnModel<Row extends object> extends ColumnModel<Row> {
+export declare class CustomTemplateColumnModel<Row> extends ColumnModel<Row> {
     private readonly config;
-    constructor(columnId: string, order: ColumnOrderManager, defaults: ColumnModel.TextPropertiesProvider);
+    constructor(columnId: string, defaults: ColumnModel.TextPropertiesProvider);
     setTemplate(templateRef: TemplateRef<any>, viewContainer: ViewContainerRef, fillCell: boolean, padChild: boolean): void;
     selectRowOnClick(selectOnRowClick: boolean): this;
 }

package/lib/components/tables/column/custom-value-column-model.d.ts

@@ -1,9 +1,8 @@
 import { ComponentType } from "@angular/cdk/overlay";
-import { type CellRendererOptions, ColumnModel, type OnComponentInit } from "./column-model";
-import type { ColumnOrderManager } from "./column-order-manager";
-export declare class CustomValueColumnModel<Row extends object, V> extends ColumnModel<Row> {
+import { CellRendererOptions, ColumnModel, OnComponentInit } from "./column-model";
+export declare class CustomValueColumnModel<Row, V> extends ColumnModel<Row> {
     private getValue;
-    constructor(columnId: string, order: ColumnOrderManager, defaults: ColumnModel.TextPropertiesProvider, getValue: (row: Row) => V);
+    constructor(columnId: string, defaults: ColumnModel.TextPropertiesProvider, getValue: (row: Row) => V);
     cellRenderer<C extends {
         value: Partial<V>;
     }>(componentType: ComponentType<C>, onComponentInitOrOptions?: CellRendererOptions<Row, C> | OnComponentInit<C>): this;

package/lib/components/tables/column/editor-controls-column-model.d.ts

@@ -0,0 +1,13 @@
+import { ComponentType } from "@angular/cdk/overlay";
+import { Command, DirtyTrackingForm } from "@coolon/pectin";
+import { EditSession } from "../editor/edit-session";
+import { ColumnModel } from "./column-model";
+export declare class EditorControlColumnModel<Row> extends ColumnModel<Row> {
+    constructor(columnId: string, saveCommandFactory: Command.Factory<DirtyTrackingForm<Row>, boolean | Promise<boolean>>, defaults: ColumnModel.TextPropertiesProvider);
+    cellRenderer(componentType: ComponentType<{
+        row: Row;
+        editSession: EditSession<Row>;
+        editRowCommand: Command<void>;
+    }>): this;
+    protected getDefaultHeaderText(): string;
+}

package/lib/components/tables/column/list-propery-column-model.d.ts

@@ -1,14 +1,16 @@
 import { ComponentType } from "@angular/cdk/overlay";
-import { Types } from "@coolon/pectin";
-import type { CellRenderer } from "../renderer/cell-renderer";
+import { Types, Validator } from "@coolon/pectin";
+import { CellListEditorComponent } from "../renderer/cell-editors";
+import { CellRenderer } from "../renderer/cell-renderer";
 import { ColumnModel } from "./column-model";
-import type { ColumnOrderManager } from "./column-order-manager";
-export declare class ListPropertyColumnModel<Row extends object, P extends Types.ArrayPropertiesOf<Row>> extends ColumnModel<Row> {
+export declare class ListPropertyColumnModel<Row, P extends Types.ArrayPropertiesOf<Row>> extends ColumnModel<Row> {
     readonly property: P;
     private _userFormat;
     private _defaultSearchTextFormat;
-    constructor(id: string, order: ColumnOrderManager, property: P, defaults: ColumnModel.TextPropertiesProvider);
+    constructor(id: string, property: P, defaults: ColumnModel.TextPropertiesProvider);
     cellRenderer(componentType: ComponentType<CellRenderer<Types.ArrayElementType<Row, P>[]>>): Omit<this, "format">;
+    cellEditor<C extends CellListEditorComponent<Types.ArrayElementType<Row, P>>>(editor: ComponentType<C>, validators?: Validator<Types.ArrayElementType<Row, P>[]>[], initialiseComponent?: (component: C) => void): this;
+    cellEditor<C extends CellListEditorComponent<Types.ArrayElementType<Row, P>>>(editor: ComponentType<C>, initialiseComponent?: (component: C) => void): this;
     format(formatter: (value: Types.ArrayElementType<Row, P>[]) => any): Omit<this, "cellRenderer">;
     selectRowOnClick(selectRowOnClick: boolean): this;
 }

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

@@ -1,14 +1,14 @@
 import { ComponentType } from "@angular/cdk/overlay";
-import { Types } from "@coolon/pectin";
-import type { CellRenderer } from "../renderer/cell-renderer";
-import type { EditableCellRenderer } from "../renderer/editable-cell-renderer";
-import { type CellRendererOptions, ColumnModel, type MutableCellRendererOptions, type OnComponentInit } from "./column-model";
-import type { ColumnOrderManager } from "./column-order-manager";
-export declare class PropertyColumnModel<Row extends object, P extends Types.ValuePropertiesOf<Row>> extends ColumnModel<Row> {
+import { Types, Validator } from "@coolon/pectin";
+import { EditableCellRenderer } from "../editor/editable-cell-renderer";
+import { CellEditorComponent } from "../renderer/cell-editors";
+import { CellRenderer } from "../renderer/cell-renderer";
+import { CellRendererOptions, ColumnModel, MutableCellRendererOptions, OnComponentInit } from "./column-model";
+export declare class PropertyColumnModel<Row, P extends Types.ValuePropertiesOf<Row>> extends ColumnModel<Row> {
     readonly property: P;
     private _userFormat;
     private _defaultSearchTextFormatter;
-    constructor(id: string, order: ColumnOrderManager, property: P, defaults: ColumnModel.TextPropertiesProvider);
+    constructor(id: string, property: P, defaults: ColumnModel.TextPropertiesProvider);
     cellRenderer<E extends CellRenderer<Row[P]>>(componentType: ComponentType<E>, options?: CellRendererOptions<Row, E>): Omit<this, "format">;
     cellRenderer<E extends CellRenderer<Row[P]>>(componentType: ComponentType<E>, onComponentInit?: OnComponentInit<E>): Omit<this, "format">;
     liveEditCellRenderer<E extends EditableCellRenderer<Row[P]>>(componentType: ComponentType<E>, options: MutableCellRendererOptions<Row, E, P>): this;
@@ -18,6 +18,8 @@ export declare class PropertyColumnModel<Row extends object, P extends Types.Val
      * @param options
      */
     mutableCellRenderer<E extends EditableCellRenderer<Row[P]>>(componentType: ComponentType<E>, options: MutableCellRendererOptions<Row, E, P>): this;
+    cellEditor<E extends CellEditorComponent<Row[P]>>(editor: ComponentType<E>, validators?: Validator<Row[P]>[], initialiseComponent?: (component: E) => void): this;
+    cellEditor<E extends CellEditorComponent<Row[P]>>(editor: ComponentType<E>, initialiseComponent?: (component: E) => void): this;
     format(formatter: (value: Row[P]) => any): Omit<this, "cellRenderer">;
     selectRowOnClick(selectOnRowClick: boolean): this;
 }

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

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

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

@@ -0,0 +1,17 @@
+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 EditRowControls<Row> extends DisposableComponent {
+    row: Row;
+    accessor editRowCommand: Command<void>;
+    private _session;
+    set editSession(session: EditSession<Row>);
+    get editSession(): EditSession<Row>;
+    readonly saveCommand: Command<void>;
+    readonly cancelCommand: Command<void>;
+    constructor();
+    get form(): DirtyTrackingForm<Row>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EditRowControls<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<EditRowControls<any>, "aup-row-editor-controls", never, { "row": { "alias": "row"; "required": false; }; "editRowCommand": { "alias": "editRowCommand"; "required": false; }; "editSession": { "alias": "editSession"; "required": false; }; }, {}, never, never, false, never>;
+}

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

@@ -0,0 +1,9 @@
+import { Command, DirtyTrackingForm, GarbageCollector } from '@coolon/pectin';
+export declare class EditSession<Row> extends GarbageCollector {
+    readonly rowId: any;
+    readonly form: DirtyTrackingForm<Row>;
+    readonly saveCommand: Command<boolean | Promise<boolean>>;
+    private _liveRowValue$;
+    readonly liveRowValue$: import("@coolon/pectin").ValueModel<Row>;
+    constructor(rowId: any, row: Row, form: DirtyTrackingForm<Row>, saveCommand: Command<boolean | Promise<boolean>>);
+}

package/lib/components/tables/{renderer → editor}/editable-cell-renderer.d.ts

@@ -1,5 +1,5 @@
+import { CellRenderer } from '../renderer/cell-renderer';
 import { Disposable } from '@coolon/pectin';
-import type { CellRenderer } from './cell-renderer';
 export interface EditableCellRenderer<T> extends CellRenderer<T> {
     value: T;
     onValueEdited(callback: (is: T, was: T) => void): Disposable;

package/lib/components/tables/filter/enable-cell-text-search.decorator.d.ts

@@ -1,8 +1,8 @@
 import { ComponentType } from "@angular/cdk/overlay";
 import { Constructable } from "@coolon/typescript-utilities";
 import { Enum } from "typescript-string-enums";
-import type { CellRenderer } from "../renderer/cell-renderer";
 import { ColumnTextSearchFormatter } from "./column-text-search-formatter";
+import { CellRenderer } from "../renderer/cell-renderer";
 export declare const Keys: {
     useFunction: "useFunction";
     useInstance: "useInstance";

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

@@ -1,5 +1,5 @@
 import { Disposable, DisposedWith, GarbageCollector, ListModel, Predicate, ValueModel } from "@coolon/pectin";
-import type { TextSearchPredicate } from "./text-search-predicate";
+import { TextSearchPredicate } from "./text-search-predicate";
 export declare class TableFilterModel<Row> extends GarbageCollector {
     private readonly _source$;
     private readonly _rowPredicate$;

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

@@ -1,10 +1 @@
-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/renderer/cell-editors.d.ts

@@ -0,0 +1,9 @@
+import { FormListModel, FormValueModel, MutableListModel, MutableValueModel } from '@coolon/pectin';
+export interface CellEditorComponent<T> {
+    value$: MutableValueModel<T> | FormValueModel<T>;
+    requestFocus?(): void;
+}
+export interface CellListEditorComponent<T> {
+    list$: MutableListModel<T> | FormListModel<T>;
+    requestFocus?(): void;
+}

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

@@ -1,50 +1,53 @@
 import { ComponentType } from '@angular/cdk/overlay';
-import { Host, TemplateRef, ViewContainerRef } from '@angular/core';
-import type { ColumnModel, RowData } from '../column/column-model';
-import type { TableCellComponent } from './table-cell/table-cell.component';
-import type { TableHeaderCellComponent } from './table-header-cell/table-header-cell.component';
+import { 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 abstract class CellPortalRef<Row extends object, Host, Portal> {
-    abstract initialiseHost(host: Host): void;
-    abstract onPortalAttached(host: Host, portalComponent: Portal): void;
+export declare const PORTAL_EDITOR_COMPONENT: unique symbol;
+export declare abstract class CellPortalRef<Row, Host, Portal> {
+    constructor();
+    abstract initialiseHost(host: Host, columnModel: ColumnModel<Row>): any;
+    abstract onPortalAttached(host: Host, portalComponent: Portal): any;
 }
-export declare class CellHeaderPortalRef<Row extends object, C> extends CellPortalRef<Row, TableHeaderCellComponent, C> {
+export declare class CellHeaderPortalRef<Row, 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;
+    initialiseHost(host: TableHeaderCellComponent, columnModel: ColumnModel<Row>): void;
     onPortalAttached(host: TableHeaderCellComponent, portalComponent: C): void;
 }
-export declare abstract class CellRendererPortalRef<Row extends object, Portal> extends CellPortalRef<Row, TableCellComponent<Row>, Portal> {
+export declare abstract class CellRendererPortalRef<Row, Portal> extends CellPortalRef<Row, TableCellComponent<Row>, Portal> {
     abstract pushState(host: TableCellComponent<Row>): void;
 }
-export declare class ComponentCellRendererPortalRef<Row extends object, Portal> extends CellRendererPortalRef<Row, Portal> {
+export declare class ComponentCellRendererPortalRef<Row, 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: Host): void;
+    initialiseHost(host: TableCellComponent<Row>, columnModel: ColumnModel<Row>): void;
     onPortalAttached(host: TableCellComponent<Row>, portalComponent: Portal): void;
     pushState(host: TableCellComponent<Row>): void;
 }
-export declare class TemplateCellRendererPortalRef<Row extends object> extends CellRendererPortalRef<Row, undefined> {
+export declare class CellEditorPortalRef<Row, 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;
+    onPortalAttached(host: TableCellComponent<Row>, portalComponent: Portal): void;
+}
+export declare class TemplateCellRendererPortalRef<Row> 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: Host): void;
+    initialiseHost(host: TableCellComponent<Row>, columnModel: ColumnModel<Row>): 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/default-cell-renderer/default-cell-renderer.component.d.ts

@@ -1,9 +1,10 @@
-import type { CellRenderer } from "../cell-renderer";
+import { CellRenderer } from "../cell-renderer";
 import * as i0 from "@angular/core";
 export declare class DefaultCellRendererComponent<T> implements CellRenderer<T> {
     private _value;
     set value(value: T);
     get value(): T;
+    constructor();
     static ɵfac: i0.ɵɵFactoryDeclaration<DefaultCellRendererComponent<any>, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<DefaultCellRendererComponent<any>, "aup-default-cell-renderer", never, { "value": { "alias": "value"; "required": false; }; }, {}, never, never, false, never>;
 }

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

@@ -1,6 +1,7 @@
 import * as i0 from "@angular/core";
 export declare class DefaultHeaderCellRendererComponent {
     headerText: string;
+    constructor();
     static ɵfac: i0.ɵɵFactoryDeclaration<DefaultHeaderCellRendererComponent, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<DefaultHeaderCellRendererComponent, "aup-default-header-renderer", never, { "headerText": { "alias": "headerText"; "required": false; }; }, {}, never, never, false, never>;
 }

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";
@@ -12,8 +12,7 @@ export declare class SelectionHeaderCellComponent<Row> extends DisposableCompone
     isIntermediate(): boolean;
     isVisible(): boolean;
     isMultiSelectionModel(): boolean;
-    ifMultiSelectionModel<T>(runnable: (model$: MultipleSelectionModel<Row, unknown>) => T, otherwise?: T): T;
-    handleClick(event$: Event): void;
+    ifMultiSelectionModel<T>(runnable: (model$: MultipleSelectionModel<Row, any>) => T, otherwise?: T): T;
     static ɵfac: i0.ɵɵFactoryDeclaration<SelectionHeaderCellComponent<any>, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<SelectionHeaderCellComponent<any>, "aup-selection-header-cell", never, {}, {}, never, never, false, never>;
 }

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

@@ -7,7 +7,6 @@ export declare class SelectionCellComponent<Row> extends DisposableComponent {
     row: Row;
     selectionModel: SelectionModel<Row>;
     color: ThemePalette;
-    constructor();
     select($event: MouseEvent): void;
     isSelected(): boolean;
     isDisabled(): boolean;

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

@@ -1,70 +1,36 @@
-import { CdkVirtualScrollViewport } from "@angular/cdk/scrolling";
-import { AfterViewInit, ElementRef, InjectionToken, OnChanges, OnDestroy } from "@angular/core";
-import { ListModel, ListModelChain, MutableValueModel, ValueModel } from "@coolon/pectin";
-import { TableVirtualScrollDataSource } from "ng-table-virtual-scroll";
+import { ElementRef, EventEmitter, NgZone, OnInit } from "@angular/core";
+import { ListModel, ListModelChain, ValueModel } from "@coolon/pectin";
 import { ResizeAwareComponent } from "../../../resize-aware.component";
 import { AbstractTableModel } from "../../abstract-table-model";
-import type { ColumnModel } from "../../column/column-model";
-import { FooterRowModel, ResolvedFooterRow } from "../../footer/footer-row-model";
+import { ColumnModel } from "../../column/column-model";
 import * as i0 from "@angular/core";
-export declare const AUP_TABLE_VIRTUAL_SCROLL_BUFFER_MULTIPLIER: InjectionToken<number>;
-export declare const AUP_TABLE_OPTIMIZED_CHANGE_DETECTION: InjectionToken<boolean>;
-export declare class TableRowAttributesDirective implements OnChanges {
-    protected readonly elementRef: ElementRef<HTMLElement>;
-    aupTableRowAttributes: Record<string, string>;
-    /** Attribute names applied on the previous pass, so ones that disappear can be removed. */
-    private appliedAttributeNames;
-    constructor(elementRef: ElementRef<HTMLElement>);
-    ngOnChanges(): 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, OnDestroy {
-    protected bufferMultiplier: number;
+export declare class TableBodyComponent<Row> extends ResizeAwareComponent implements OnInit {
     accessor data$: ListModel<Row>;
     accessor tableModel: AbstractTableModel<Row>;
-    footerRows: FooterRowModel.Impl[];
     accessor showHeader$: ValueModel<boolean>;
     accessor showHeader: boolean;
+    readonly visibleRowCount: EventEmitter<number>;
     trackBy: (index: number, item: Row) => any;
-    accessor scrollMode$: ValueModel<TableBodyComponent.ScrollMode>;
-    accessor scrollMode: TableBodyComponent.ScrollMode;
-    scrollViewport: CdkVirtualScrollViewport;
-    columns$: ListModelChain<ColumnModel<Row>>;
-    columnIds$: ListModelChain<string>;
-    footerRowDefs$: ValueModel<ResolvedFooterRow[]>;
-    private columnsById$;
-    protected readonly headerHeight$: MutableValueModel<number>;
-    protected rowHeight$: MutableValueModel<number>;
+    /**
+     * 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;
+    columns: ListModelChain<ColumnModel<Row>>;
+    columnIds: ListModelChain<string>;
+    private columnsById;
+    readonly _visibleRowCount: ValueModel<number>;
+    private readonly headerHeight;
+    private readonly rowHeight;
     baseCssClass: string;
-    get animationsDisabledClass(): boolean;
-    protected readonly virtualScrollDataSource: TableVirtualScrollDataSource<Row>;
-    protected readonly virtualScrollActive$: MutableValueModel<boolean>;
-    protected readonly animationsDisabled$: MutableValueModel<boolean>;
-    private scrollTimeout;
-    private animationsResetRafId;
-    private scrollEndAbortController;
-    protected readonly optimisedChangeDetectionEnabled: boolean;
-    private viewInitialized;
-    protected markForCheck(): void;
-    constructor(bufferMultiplier?: number);
-    ngAfterViewInit(): void;
+    constructor(elementRef: ElementRef, ngZone: NgZone);
     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[];
-    private scheduleTableHeightCheck;
-    private notifyScrolled;
-    private notifyScrollEnded;
-    ngOnDestroy(): void;
-    private resetAnimationsAfterFrame;
-    private clearScrollTimeout;
-    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; }; "footerRows": { "alias": "footerRows"; "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";
+    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>;
 }

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

@@ -1,23 +1,32 @@
 import { CdkPortalOutletAttachedRef, Portal } from "@angular/cdk/portal";
-import { OnChanges, SimpleChanges } from '@angular/core';
+import { OnChanges, SimpleChanges } from "@angular/core";
 import { DisposableComponent } from "../../../disposable-component";
 import { AbstractTableModel } from "../../abstract-table-model";
-import { ColumnModel, type RowData } from "../../column/column-model";
-import { CELL_RENDERER_PORTAL } from "../cell-portal-ref";
+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 object> extends DisposableComponent implements OnChanges {
+export declare class TableCellComponent<Row> extends DisposableComponent implements OnChanges {
     row: Row;
     column: ColumnModel<Row>;
+    editSession: EditSession<Row>;
     tableModel: AbstractTableModel<Row>;
+    private 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;
+    initialiseEditor(ref: CdkPortalOutletAttachedRef): void;
+    private tryAndFocusEditor;
     ngOnChanges(changes: SimpleChanges): void;
     getRendererPortal(): Portal<any>;
+    getEditorPortal(): Portal<any>;
     getRowData(): RowData<Row>;
     static ɵfac: i0.ɵɵFactoryDeclaration<TableCellComponent<any>, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<TableCellComponent<any>, "aup-table-cell", never, { "row": { "alias": "row"; "required": false; }; "column": { "alias": "column"; "required": false; }; "tableModel": { "alias": "tableModel"; "required": false; }; }, {}, never, never, false, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TableCellComponent<any>, "aup-table-cell", never, { "row": { "alias": "row"; "required": false; }; "column": { "alias": "column"; "required": false; }; "editSession": { "alias": "editSession"; "required": false; }; "tableModel": { "alias": "tableModel"; "required": false; }; }, {}, never, never, false, never>;
 }

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

@@ -7,6 +7,7 @@ export declare class TableHeaderCellComponent implements OnInit {
     column: ColumnModel<any>;
     defaultClassNames: string;
     [HEADER_CELL_RENDERER_PORTAL]: Portal<any>;
+    constructor();
     ngOnInit(): void;
     initialiseHeader(ref: CdkPortalOutletAttachedRef): void;
     getPortal(): Portal<any>;

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

@@ -0,0 +1,15 @@
+import { Command, ValueModel } from "@coolon/pectin";
+import { DisposableComponent } from "../../../../disposable-component";
+import * as i0 from "@angular/core";
+export declare class TableMoreMenuPopupComponent<T> extends DisposableComponent {
+    private _value$;
+    private readonly _visible$;
+    private readonly _closeCommand;
+    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>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableMoreMenuPopupComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TableMoreMenuPopupComponent<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

@@ -0,0 +1,23 @@
+import { CdkPortalOutletAttachedRef, ComponentPortal } from "@angular/cdk/portal";
+import { MatLegacyMenuTrigger as MatMenuTrigger } from "@angular/material/legacy-menu";
+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 * as i0 from "@angular/core";
+export declare class TableMoreMenuComponent<T> extends DisposableComponent implements CellRenderer<T> {
+    private value$;
+    accessor value: T;
+    matMenuTrigger: MatMenuTrigger;
+    private readonly popupType$;
+    popupComponentPortal$: ValueModelChain<ComponentPortal<TableMoreMenuPopupComponent<T>>>;
+    private readonly _visible$;
+    constructor();
+    configurePopupComponentType(popupComponentType: Constructable<TableMoreMenuPopupComponent<T>>): 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>;
+}