@coolon/angular-ui-powerups 12.4.9 → 13.0.0

package/esm2020/lib/components/tables/table/column-model.mjs

@@ -0,0 +1,392 @@
+import { __decorate, __metadata } from "tslib";
+import { ComponentRef } from "@angular/core";
+import { DelegatingSelectionModel, DelegatingValueModel, GarbageCollector, MultipleSelectionModel, ValueModel } from '@coolon/pectin';
+import { assert, lang, Stringy } from "@coolon/typescript-utilities";
+import { Memoize } from '@typescript-plus/fast-memoize-decorator';
+import { isFunction } from 'lodash';
+import { CellEditorPortalRef, CellHeaderPortalRef, ComponentCellRendererPortalRef, TemplateCellRendererPortalRef } from './cell-portal-ref';
+import { DefaultCellRendererComponent } from './default-cell-renderer/default-cell-renderer.component';
+import { DefaultHeaderCellRendererComponent } from './default-header-cell-renderer/default-header-cell-renderer.component';
+import { EditRowControls } from './edit-row-controls/edit-row-controls.component';
+import { SelectCellRendererComponent } from './select-cell-renderer/select-cell-renderer.component';
+import { SelectHeaderCellRendererComponent } from './select-header-cell-renderer/select-header-cell-renderer.component';
+const noop = () => {
+};
+const CELL_RENDERER_COMPONENT_ROW_CACHE = Symbol('aup-cell-renderer:row-data-cache');
+const DEFAULT_TEXT_SEARCH_PREDICATE = (row, text) => false;
+export class ColumnModel extends GarbageCollector {
+    constructor(columnId, textPropertiesProvider) {
+        super();
+        this.columnId = columnId;
+        this.textPropertiesProvider = textPropertiesProvider;
+        this._enableRowSelection = true;
+        this._flex = false;
+        this._defaultVisibility = this.registerDisposable(new DelegatingValueModel().withDefault(true));
+        this._visible = this.registerDisposable(new DelegatingValueModel().withDefault(this._defaultVisibility));
+        this._columnModelTextSearchPredicate = undefined;
+        this._cellRendererTextSearchPredicate = undefined;
+        this.installHeaderRenderer();
+        this.dasherisedColumnId = Stringy.from(columnId).dasherize().toString();
+    }
+    installHeaderRenderer() {
+        this.cellHeaderRenderer(DefaultHeaderCellRendererComponent, (component, column) => {
+            component.headerText = column.getHeaderText();
+        });
+    }
+    getHeaderText() {
+        return this.getColumnTextProperties()?.headerText() || this.getDefaultHeaderText();
+    }
+    isVisible() {
+        return this.visible.value;
+    }
+    get visible() {
+        return this._visible.readonly;
+    }
+    visibleWhile(visible) {
+        this._visible.setDelegate(visible);
+        return this;
+    }
+    setDefaultVisibility(visible) {
+        this._defaultVisibility.setDelegate(visible);
+    }
+    getDefaultHeaderText() {
+        return this.columnId;
+    }
+    get isTextMatch() {
+        return this._columnModelTextSearchPredicate || this._cellRendererTextSearchPredicate || DEFAULT_TEXT_SEARCH_PREDICATE;
+    }
+    /**
+     * Sets the predicate to use when checking if the specified row is a text match for this column.
+     * @param predicate
+     */
+    useTextSearchPredicate(predicate) {
+        this._columnModelTextSearchPredicate = predicate;
+        return this;
+    }
+    getColumnTextProperties() {
+        return this._columnTextProperties || this.textPropertiesProvider();
+    }
+    /**
+     * @deprecated use #columnTextProperties instead
+     * @param columnTextProperties
+     */
+    textProperties(columnTextProperties) {
+        return this.columnTextProperties(columnTextProperties);
+    }
+    columnTextProperties(columnTextProperties) {
+        this._columnTextProperties = columnTextProperties;
+        return this;
+    }
+    configureHeaderRenderer(config) {
+        this._columnHeaderPortalRef = config;
+    }
+    configureCellRenderer(config) {
+        this._cellRendererPortalRef = config;
+    }
+    configureCellEditor(cellEditor) {
+        this._cellEditorPortalRef = cellEditor;
+    }
+    cellHeaderRenderer(componentType, initialiser) {
+        this.configureHeaderRenderer(new CellHeaderPortalRef(componentType, initialiser));
+        return this;
+    }
+    flex(flex = true) {
+        this._flex = flex;
+    }
+    isFlex() {
+        return this._flex;
+    }
+    hasEditorPortal() {
+        return !!this._cellEditorPortalRef;
+    }
+    attachHeaderCell(host) {
+        this._columnHeaderPortalRef.initialiseHost(host, this);
+    }
+    attachCell(host) {
+        this._cellRendererPortalRef.initialiseHost(host, this);
+        if (this.hasEditorPortal()) {
+            this._cellEditorPortalRef.initialiseHost(host, this);
+        }
+    }
+    onHeaderAttached(host, ref) {
+        const component = this.getComponent(ref);
+        this._columnHeaderPortalRef.onPortalAttached(host, component);
+    }
+    onRendererAttached(host, ref) {
+        const component = this.getComponentOrEmbeddedView(ref);
+        this._cellRendererPortalRef.onPortalAttached(host, component);
+        if (isFunction(component?.matches)) {
+            this._cellRendererTextSearchPredicate = (row, text) => component.matches(row, text);
+        }
+        else {
+            this._cellRendererTextSearchPredicate = undefined;
+        }
+    }
+    // @Trace()
+    onEditorAttached(host, ref) {
+        this._cellEditorPortalRef.onPortalAttached(host, this.getComponent(ref));
+    }
+    updatePortalContent(host) {
+        this._cellRendererPortalRef.pushState(host);
+    }
+    _selectRowOnClick(selectRowOnClick) {
+        this._enableRowSelection = selectRowOnClick;
+        return this;
+    }
+    isRowSelectionEnabled() {
+        return this._enableRowSelection;
+    }
+    getComponent(ref) {
+        if (ref instanceof ComponentRef) {
+            return ref.instance;
+        }
+        else {
+            console.error("headers only support component portals, got", ref);
+            lang.illegalState(`headers only support component portals, got ${ref}`);
+        }
+    }
+    getComponentOrEmbeddedView(ref) {
+        if (ref instanceof ComponentRef) {
+            return ref.instance;
+        }
+        else {
+            return ref;
+        }
+    }
+}
+__decorate([
+    Memoize(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", String)
+], ColumnModel.prototype, "getHeaderText", null);
+__decorate([
+    Memoize(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Object)
+], ColumnModel.prototype, "getColumnTextProperties", null);
+export class PropertyColumnModel extends ColumnModel {
+    constructor(id, property, defaults) {
+        super(id, defaults);
+        this.property = property;
+        this._format = (value) => value?.toString();
+        this.cellRenderer(DefaultCellRendererComponent);
+        this.useTextSearchPredicate((row, regex) => {
+            return regex.test(this._format(row[this.property]));
+        });
+    }
+    cellRenderer(componentType, onComponentInitOrOptions) {
+        this.configureCellRenderer(new ComponentCellRendererPortalRef(componentType, (component, rowData, firstTime) => {
+            if (firstTime) {
+                if (isFunction(onComponentInitOrOptions)) {
+                    onComponentInitOrOptions(component);
+                }
+                else {
+                    if (isFunction(onComponentInitOrOptions?.onComponentInit)) {
+                        onComponentInitOrOptions.onComponentInit(component);
+                    }
+                }
+            }
+            component.value = this._format(rowData.row[this.property]);
+        }));
+        return this;
+    }
+    liveEditCellRenderer(componentType, options) {
+        return this.mutableCellRenderer(componentType, options);
+    }
+    /**
+     * Deprecated.  Use #liveEditCellRenderer instead.
+     * @param componentType
+     * @param options
+     */
+    mutableCellRenderer(componentType, options) {
+        this.configureCellRenderer(new ComponentCellRendererPortalRef(componentType, (component, rowData, firstTime) => {
+            // keep a local copy most recent row value so it's available to teh
+            // edit callback without having to add/remove subscribers all the time.
+            component[CELL_RENDERER_COMPONENT_ROW_CACHE] = rowData.row;
+            let disableEditCallback = false;
+            if (firstTime) {
+                if (isFunction(options?.onComponentInit)) {
+                    options.onComponentInit(component);
+                }
+                // install our edit callback
+                component.onValueEdited((is, was) => {
+                    if (!disableEditCallback) {
+                        options.onValueEdit(component[CELL_RENDERER_COMPONENT_ROW_CACHE], is, was);
+                    }
+                });
+            }
+            // now push the value the component and disable the callback just incase the component misbehaves
+            // and fires a value change during the operation.
+            disableEditCallback = true;
+            component.value = rowData.row[this.property];
+            disableEditCallback = false;
+            if (!isFunction(options) && isFunction(options?.onRowUpdate)) {
+                options.onRowUpdate(component, rowData.row);
+            }
+        }));
+        return this;
+    }
+    cellEditor(editor, validatorsOrInitialiser, onComponentInit) {
+        const validators = Array.isArray(validatorsOrInitialiser) ? validatorsOrInitialiser : undefined;
+        const initialiser = isFunction(validatorsOrInitialiser) ? validatorsOrInitialiser : onComponentInit;
+        this.configureCellEditor(new CellEditorPortalRef(editor, (component, editSession) => {
+            const formValueModel = editSession.form.pluck(this.property);
+            if (validators) {
+                formValueModel.validateUsing(validators);
+            }
+            component.valueModel = formValueModel;
+            if (initialiser) {
+                initialiser(component);
+            }
+        }));
+        return this;
+    }
+    format(formatter) {
+        assert.isFunction(formatter);
+        this._format = formatter;
+        return this;
+    }
+    selectRowOnClick(selectOnRowClick) {
+        return this._selectRowOnClick(selectOnRowClick);
+    }
+}
+export class ListPropertyColumnModel extends ColumnModel {
+    constructor(id, property, defaults) {
+        super(id, defaults);
+        this.property = property;
+        this._format = (value) => value.map(v => v?.toString()).join(', ');
+        this.cellRenderer(DefaultCellRendererComponent);
+        this.useTextSearchPredicate((row, regex) => {
+            let rowElement = row[this.property];
+            // @ts-ignore Started complaining in ts 4.5.. but I think my logic is correct...
+            return regex.test(this._format(rowElement));
+        });
+    }
+    cellRenderer(componentType) {
+        this.configureCellRenderer(new ComponentCellRendererPortalRef(componentType, (component, rowData) => {
+            let rowElement = rowData.row[this.property];
+            // @ts-ignore Started complaining in ts 4.5.. but I think my logic is correct...
+            component.value = this._format(rowElement);
+        }));
+        return this;
+    }
+    cellEditor(editor, validatorsOrInitialiser, initialiseComponent) {
+        const validators = Array.isArray(validatorsOrInitialiser) ? validatorsOrInitialiser : undefined;
+        const initialiser = isFunction(validatorsOrInitialiser) ? validatorsOrInitialiser : initialiseComponent;
+        this.configureCellEditor(new CellEditorPortalRef(editor, (component, editSession) => {
+            const formListModel = editSession.form.pluckList(this.property);
+            if (validators) {
+                formListModel.validateUsing(validators);
+            }
+            component.listModel = formListModel;
+            if (initialiser) {
+                initialiser(component);
+            }
+        }));
+        return this;
+    }
+    format(formatter) {
+        assert.isFunction(formatter);
+        this._format = formatter;
+        return this;
+    }
+    selectRowOnClick(selectRowOnClick) {
+        return this._selectRowOnClick(selectRowOnClick);
+    }
+}
+export class CustomValueColumnModel extends ColumnModel {
+    constructor(columnId, defaults, getValue) {
+        super(columnId, defaults);
+        this.getValue = getValue;
+        this.cellRenderer(DefaultCellRendererComponent);
+    }
+    cellRenderer(componentType, onComponentInitOrOptions) {
+        this.configureCellRenderer(new ComponentCellRendererPortalRef(componentType, (component, rowData, firstTime) => {
+            if (firstTime) {
+                if (isFunction(onComponentInitOrOptions)) {
+                    onComponentInitOrOptions(component);
+                }
+                else {
+                    if (isFunction(onComponentInitOrOptions?.onComponentInit)) {
+                        onComponentInitOrOptions.onComponentInit(component);
+                    }
+                }
+            }
+            component.value = this.getValue(rowData.row);
+            if (!isFunction(onComponentInitOrOptions) && isFunction(onComponentInitOrOptions?.onRowUpdate)) {
+                onComponentInitOrOptions.onRowUpdate(component, rowData.row);
+            }
+        }));
+        return this;
+    }
+    selectRowOnClick(selectOnRowClick) {
+        return this._selectRowOnClick(selectOnRowClick);
+    }
+}
+export class EditorControlColumnModel extends ColumnModel {
+    constructor(columnId, saveCommandFactory, defaults) {
+        super(columnId, defaults);
+        this.cellRenderer(EditRowControls);
+    }
+    cellRenderer(componentType) {
+        this.configureCellRenderer(new ComponentCellRendererPortalRef(componentType, (component, rowData) => {
+            component.row = rowData.row;
+            component.editSession = rowData.editSession;
+            component.editRowCommand = rowData.editRowCommand;
+        }));
+        return this;
+    }
+    getDefaultHeaderText() {
+        return '';
+    }
+}
+export class CustomTemplateColumnModel extends ColumnModel {
+    constructor(columnId, defaults) {
+        super(columnId, defaults);
+        this.config = new TemplateCellRendererPortalRef();
+        this.configureCellRenderer(this.config);
+    }
+    setTemplate(templateRef, viewContainer, fillCell, padChild) {
+        this.config.registerPortal(templateRef, viewContainer, fillCell, padChild);
+    }
+    selectRowOnClick(selectOnRowClick) {
+        return this._selectRowOnClick(selectOnRowClick);
+    }
+}
+export class SelectionColumnModel extends ColumnModel {
+    constructor(columnId, defaults, selectionModel) {
+        super(columnId, defaults);
+        this._enableHeaderControls = true;
+        this.selectionModel = DelegatingSelectionModel.createDelegate();
+        this._selectRowOnClick(false);
+        this.cellHeaderRenderer(SelectHeaderCellRendererComponent, (component) => {
+            component.selectionModel = this.selectionModel;
+            component.enableHeaderControls = this._enableHeaderControls;
+        });
+        this.configureCellRenderer(new ComponentCellRendererPortalRef(SelectCellRendererComponent, (component, rowData) => {
+            component.row = rowData.row;
+            component.selectionModel = this.selectionModel;
+        }));
+        this.setSelectionModel(selectionModel);
+    }
+    setSelectionModel(selectionModel) {
+        this.selectionModel.setDelegate(selectionModel);
+        this.setDefaultVisibility(selectionModel instanceof MultipleSelectionModel ? ValueModel.TRUE : ValueModel.FALSE);
+    }
+    getDefaultHeaderText() {
+        return '';
+    }
+    enableHeaderControls(enable) {
+        this._enableHeaderControls = enable;
+        return this;
+    }
+    selectRow(row) {
+        this.selectionModel.selectCommand.execute(row);
+    }
+    isSelected(row) {
+        return this.selectionModel.isSelected(row);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"column-model.js","sourceRoot":"","sources":["../../../../../../../../libs/angular-ui-powerups/src/lib/components/tables/table/column-model.ts"],"names":[],"mappings":"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","sourcesContent":["import { ComponentType } from '@angular/cdk/overlay';\nimport { CdkPortalOutletAttachedRef } from \"@angular/cdk/portal/portal-directives\";\nimport { ComponentRef, TemplateRef, ViewContainerRef } from \"@angular/core\";\nimport {\n  Command, CommandFactory,\n  DelegatingSelectionModel,\n  DelegatingValueModel,\n  DirtyTrackingForm,\n  GarbageCollector,\n  MultipleSelectionModel,\n  SelectionModel,\n  Types,\n  UnaryCommand,\n  Validator,\n  ValueModel\n} from '@coolon/pectin';\nimport { assert, lang, Stringy } from \"@coolon/typescript-utilities\";\nimport { Memoize } from '@typescript-plus/fast-memoize-decorator';\n\nimport { isFunction } from 'lodash';\nimport { CellEditorComponent, CellListEditorComponent } from './cell-editors';\nimport {\n  CellEditorPortalRef,\n  CellHeaderPortalRef,\n  CellRendererPortalRef,\n  ComponentCellRendererPortalRef,\n  TemplateCellRendererPortalRef\n} from './cell-portal-ref';\nimport { CellRenderer } from './cell-renderer';\nimport { ColumnTextProperties } from './column-text-properties';\nimport { DefaultCellRendererComponent } from './default-cell-renderer/default-cell-renderer.component';\nimport { DefaultHeaderCellRendererComponent } from './default-header-cell-renderer/default-header-cell-renderer.component';\nimport { EditRowControls } from './edit-row-controls/edit-row-controls.component';\nimport { EditSession } from '../edit-session';\nimport { MutableCellRenderer } from './mutable-cell-renderer';\nimport { SelectCellRendererComponent } from './select-cell-renderer/select-cell-renderer.component';\nimport { SelectHeaderCellRendererComponent } from './select-header-cell-renderer/select-header-cell-renderer.component';\nimport { TableCellRendererComponent } from './table-cell-renderer/table-cell-renderer.component';\nimport { TableHeaderCellRendererComponent } from './table-header-cell-renderer/table-header-cell-renderer.component';\nimport { TextSearchPredicate } from './text-search-predicate';\n\n\nconst noop = () => {\n};\n\nexport interface RowData<Row> {\n  row: Row;\n  editSession?: EditSession<Row>;\n  editRowCommand: Command<void>;\n}\n\nconst CELL_RENDERER_COMPONENT_ROW_CACHE = Symbol('aup-cell-renderer:row-data-cache');\n\nexport type OnComponentInit<C> = (component: C) => void;\n\nexport interface CellRendererOptions<Row, E> {\n  onComponentInit?: (component: E) => void;\n  onRowUpdate?: (component: E, row: Row) => void;\n}\n\n\nexport interface MutableCellRendererOptions<Row, E, P extends keyof Row> extends CellRendererOptions<Row, E> {\n  onValueEdit: (row: Row, is: Row[P], was: Row[P]) => void;\n}\n\nconst DEFAULT_TEXT_SEARCH_PREDICATE: TextSearchPredicate<unknown> = (row: unknown, text: RegExp) => false;\n\nexport class ColumnModel<Row> extends GarbageCollector {\n\n  private _columnTextProperties: ColumnTextProperties;\n\n  private _columnHeaderPortalRef: CellHeaderPortalRef<Row, any>;\n  private _cellRendererPortalRef: CellRendererPortalRef<Row, any>;\n  private _cellEditorPortalRef: CellEditorPortalRef<Row, any>;\n\n  private _enableRowSelection = true;\n  private _flex = false;\n\n  private _defaultVisibility = this.registerDisposable(new DelegatingValueModel<boolean>().withDefault(true));\n  private _visible = this.registerDisposable(new DelegatingValueModel<boolean>().withDefault(this._defaultVisibility));\n  readonly dasherisedColumnId: string;\n  protected _columnModelTextSearchPredicate: TextSearchPredicate<Row> = undefined;\n  protected _cellRendererTextSearchPredicate: TextSearchPredicate<Row> = undefined;\n\n  constructor(readonly columnId: string, private textPropertiesProvider: ColumnModel.TextPropertiesProvider) {\n    super();\n    this.installHeaderRenderer();\n    this.dasherisedColumnId = Stringy.from(columnId).dasherize().toString();\n  }\n\n  protected installHeaderRenderer() {\n    this.cellHeaderRenderer(DefaultHeaderCellRendererComponent, (component, column) => {\n      component.headerText = column.getHeaderText();\n    });\n  }\n\n  @Memoize()\n  getHeaderText(): string {\n    return this.getColumnTextProperties()?.headerText() || this.getDefaultHeaderText();\n  }\n\n  isVisible() {\n    return this.visible.value;\n  }\n\n  get visible() {\n    return this._visible.readonly;\n  }\n\n  visibleWhile(visible: ValueModel<boolean>): this {\n    this._visible.setDelegate(visible);\n    return this;\n  }\n\n  protected setDefaultVisibility(visible: ValueModel<boolean>) {\n    this._defaultVisibility.setDelegate(visible);\n  }\n\n  protected getDefaultHeaderText() {\n    return this.columnId;\n  }\n\n  get isTextMatch(): TextSearchPredicate<Row> {\n    return this._columnModelTextSearchPredicate || this._cellRendererTextSearchPredicate || DEFAULT_TEXT_SEARCH_PREDICATE;\n  }\n\n  /**\n   * Sets the predicate to use when checking if the specified row is a text match for this column.\n   * @param predicate\n   */\n  useTextSearchPredicate(predicate: TextSearchPredicate<Row>):this {\n    this._columnModelTextSearchPredicate = predicate;\n    return this;\n  }\n\n  @Memoize()\n  getColumnTextProperties(): ColumnTextProperties {\n    return this._columnTextProperties || this.textPropertiesProvider();\n  }\n\n  /**\n   * @deprecated use #columnTextProperties instead\n   * @param columnTextProperties\n   */\n  textProperties(columnTextProperties: ColumnTextProperties): this {\n    return this.columnTextProperties(columnTextProperties);\n  }\n\n  columnTextProperties(columnTextProperties: ColumnTextProperties): this {\n    this._columnTextProperties = columnTextProperties;\n    return this;\n  }\n\n  protected configureHeaderRenderer<C>(config: CellHeaderPortalRef<Row, any>): void {\n    this._columnHeaderPortalRef = config;\n  }\n\n  protected configureCellRenderer<C>(config: CellRendererPortalRef<Row, any>): void {\n    this._cellRendererPortalRef = config;\n  }\n\n  protected configureCellEditor<E>(cellEditor: CellEditorPortalRef<Row, E>): void {\n    this._cellEditorPortalRef = cellEditor;\n  }\n\n  cellHeaderRenderer<C>(componentType: ComponentType<C>, initialiser: (component: C, column: ColumnModel<Row>) => void): this {\n    this.configureHeaderRenderer(new CellHeaderPortalRef<Row, C>(componentType, initialiser));\n    return this;\n  }\n\n  flex(flex = true) {\n    this._flex = flex;\n  }\n\n  isFlex() {\n    return this._flex;\n  }\n\n  hasEditorPortal() {\n    return !!this._cellEditorPortalRef;\n  }\n\n  attachHeaderCell(host: any) {\n    this._columnHeaderPortalRef.initialiseHost(host, this);\n  }\n\n  attachCell(host: any) {\n    this._cellRendererPortalRef.initialiseHost(host, this);\n    if (this.hasEditorPortal()) {\n      this._cellEditorPortalRef.initialiseHost(host, this);\n    }\n  }\n\n  onHeaderAttached(host: TableHeaderCellRendererComponent, ref: CdkPortalOutletAttachedRef) {\n    const component = this.getComponent(ref);\n    this._columnHeaderPortalRef.onPortalAttached(host, component);\n  }\n\n  onRendererAttached(host: TableCellRendererComponent<Row>, ref: CdkPortalOutletAttachedRef) {\n    const component = this.getComponentOrEmbeddedView(ref);\n    this._cellRendererPortalRef.onPortalAttached(host, component);\n    if (isFunction(component?.matches)) {\n      this._cellRendererTextSearchPredicate = (row, text) => component.matches(row, text);\n    } else {\n      this._cellRendererTextSearchPredicate = undefined;\n    }\n  }\n\n  // @Trace()\n  onEditorAttached(host: TableCellRendererComponent<Row>, ref: CdkPortalOutletAttachedRef) {\n    this._cellEditorPortalRef.onPortalAttached(host, this.getComponent(ref));\n  }\n\n  updatePortalContent(host: TableCellRendererComponent<Row>) {\n    this._cellRendererPortalRef.pushState(host);\n  }\n\n  protected _selectRowOnClick(selectRowOnClick: boolean): this {\n    this._enableRowSelection = selectRowOnClick;\n    return this;\n  }\n\n  isRowSelectionEnabled(): boolean {\n    return this._enableRowSelection;\n  }\n\n  protected getComponent(ref: CdkPortalOutletAttachedRef): any {\n    if (ref instanceof ComponentRef) {\n      return ref.instance;\n    } else {\n      console.error(\"headers only support component portals, got\", ref);\n      lang.illegalState(`headers only support component portals, got ${ref}`)\n    }\n  }\n  protected getComponentOrEmbeddedView(ref: CdkPortalOutletAttachedRef): any {\n    if (ref instanceof ComponentRef) {\n      return ref.instance;\n    } else {\n      return ref;\n    }\n  }\n}\n\nexport namespace ColumnModel {\n  export type TextPropertiesProvider = () => ColumnTextProperties\n}\n\n\nexport class PropertyColumnModel<Row, P extends Types.ValuePropertiesOf<Row>> extends ColumnModel<Row> {\n\n  private _format: (value: Row[P]) => any = (value) => value?.toString();\n\n  constructor(id: string, readonly property: P, defaults: ColumnModel.TextPropertiesProvider) {\n    super(id, defaults);\n    this.cellRenderer(DefaultCellRendererComponent);\n    this.useTextSearchPredicate((row: Row, regex: RegExp) => {\n      return regex.test(this._format(row[this.property]));\n    });\n  }\n\n  cellRenderer<E extends CellRenderer<Row[P]>>(componentType: ComponentType<E>, options?: CellRendererOptions<Row, E>): this\n  cellRenderer<E extends CellRenderer<Row[P]>>(componentType: ComponentType<E>, onComponentInit?: OnComponentInit<E>): this\n  cellRenderer<E extends CellRenderer<Row[P]>>(componentType: ComponentType<E>, onComponentInitOrOptions?: CellRendererOptions<Row, E> | OnComponentInit<E>): this {\n    this.configureCellRenderer(new ComponentCellRendererPortalRef(componentType, (component, rowData, firstTime) => {\n      if (firstTime) {\n        if (isFunction(onComponentInitOrOptions)) {\n          onComponentInitOrOptions(component);\n        } else {\n          if (isFunction(onComponentInitOrOptions?.onComponentInit)) {\n            onComponentInitOrOptions.onComponentInit(component);\n          }\n        }\n      }\n      component.value = this._format(rowData.row[this.property]);\n    }));\n    return this;\n  }\n\n  liveEditCellRenderer<E extends MutableCellRenderer<Row[P]>>(componentType: ComponentType<E>, options: MutableCellRendererOptions<Row, E, P>): this {\n    return this.mutableCellRenderer(componentType, options);\n  }\n\n  /**\n   * Deprecated.  Use #liveEditCellRenderer instead.\n   * @param componentType\n   * @param options\n   */\n  mutableCellRenderer<E extends MutableCellRenderer<Row[P]>>(componentType: ComponentType<E>, options: MutableCellRendererOptions<Row, E, P>): this {\n\n    this.configureCellRenderer(new ComponentCellRendererPortalRef(componentType, (component, rowData, firstTime) => {\n\n      // keep a local copy most recent row value so it's available to teh\n      // edit callback without having to add/remove subscribers all the time.\n      component[CELL_RENDERER_COMPONENT_ROW_CACHE] = rowData.row;\n      let disableEditCallback = false;\n\n      if (firstTime) {\n        if (isFunction(options?.onComponentInit)) {\n          options.onComponentInit(component);\n        }\n        // install our edit callback\n        component.onValueEdited((is, was) => {\n          if (!disableEditCallback) {\n            options.onValueEdit(component[CELL_RENDERER_COMPONENT_ROW_CACHE], is, was);\n          }\n        });\n\n      }\n\n      // now push the value the component and disable the callback just incase the component misbehaves\n      // and fires a value change during the operation.\n      disableEditCallback = true;\n      component.value = rowData.row[this.property];\n      disableEditCallback = false;\n\n      if (!isFunction(options) && isFunction(options?.onRowUpdate)) {\n        options.onRowUpdate(component, rowData.row);\n      }\n\n    }));\n    return this;\n  }\n\n  cellEditor<E extends CellEditorComponent<Row[P]>>(editor: ComponentType<E>, validators?: Validator<Row[P]>[], initialiseComponent?: (component: E) => void): this\n  cellEditor<E extends CellEditorComponent<Row[P]>>(editor: ComponentType<E>, initialiseComponent?: (component: E) => void): this\n  cellEditor<E extends CellEditorComponent<Row[P]>>(editor: ComponentType<E>, validatorsOrInitialiser?: Validator<Row[P]>[] | ((component: E) => void), onComponentInit?: (component: E) => void): this {\n    const validators = Array.isArray(validatorsOrInitialiser) ? validatorsOrInitialiser : undefined;\n    const initialiser = isFunction(validatorsOrInitialiser) ? validatorsOrInitialiser : onComponentInit;\n    this.configureCellEditor(new CellEditorPortalRef(editor, (component: E, editSession: EditSession<Row>) => {\n      const formValueModel = editSession.form.pluck(this.property);\n      if (validators) {\n        formValueModel.validateUsing(validators);\n      }\n      component.valueModel = formValueModel;\n      if (initialiser) {\n        initialiser(component);\n      }\n    }));\n    return this;\n  }\n\n  format(formatter: (value: Row[P]) => any): this {\n    assert.isFunction(formatter);\n    this._format = formatter;\n    return this;\n  }\n\n  public selectRowOnClick(selectOnRowClick: boolean): this {\n    return this._selectRowOnClick(selectOnRowClick);\n  }\n\n}\n\nexport class ListPropertyColumnModel<Row, P extends Types.ArrayPropertiesOf<Row>> extends ColumnModel<Row> {\n\n  private _format: (value: Types.ArrayElementType<Row, P>[]) => any = (value) => value.map(v => v?.toString()).join(', ');\n\n  constructor(id: string, readonly property: P, defaults: ColumnModel.TextPropertiesProvider) {\n    super(id, defaults);\n    this.cellRenderer(DefaultCellRendererComponent);\n    this.useTextSearchPredicate((row: Row, regex: RegExp) => {\n      let rowElement = row[this.property];\n      // @ts-ignore Started complaining in ts 4.5.. but I think my logic is correct...\n      return regex.test(this._format(rowElement));\n    });\n  }\n\n  cellRenderer(componentType: ComponentType<{ value: Types.ArrayElementType<Row, P>[] }>): this {\n    this.configureCellRenderer(new ComponentCellRendererPortalRef(componentType, (component, rowData) => {\n      let rowElement = rowData.row[this.property];\n      // @ts-ignore Started complaining in ts 4.5.. but I think my logic is correct...\n      component.value = this._format(rowElement);\n    }));\n    return this;\n  }\n\n  cellEditor<C extends CellListEditorComponent<Types.ArrayElementType<Row, P>>>(editor: ComponentType<C>, validators?: Validator<Types.ArrayElementType<Row, P>[]>[], initialiseComponent?: (component: C) => void): this\n  cellEditor<C extends CellListEditorComponent<Types.ArrayElementType<Row, P>>>(editor: ComponentType<C>, initialiseComponent?: (component: C) => void): this\n  cellEditor<C extends CellListEditorComponent<Types.ArrayElementType<Row, P>>>(editor: ComponentType<C>, validatorsOrInitialiser?: Validator<Types.ArrayElementType<Row, P>[]>[] | ((component: C) => void), initialiseComponent?: (component: C) => void): this {\n    const validators = Array.isArray(validatorsOrInitialiser) ? validatorsOrInitialiser : undefined;\n    const initialiser = isFunction(validatorsOrInitialiser) ? validatorsOrInitialiser : initialiseComponent;\n\n    this.configureCellEditor(new CellEditorPortalRef(editor, (component: C, editSession: EditSession<Row>) => {\n      const formListModel = editSession.form.pluckList(this.property);\n      if (validators) {\n        formListModel.validateUsing(validators);\n      }\n      component.listModel = formListModel;\n      if (initialiser) {\n        initialiser(component);\n      }\n    }));\n    return this;\n  }\n\n  format(formatter: (value: Types.ArrayElementType<Row, P>[]) => any): this {\n    assert.isFunction(formatter);\n    this._format = formatter;\n    return this;\n  }\n\n  public selectRowOnClick(selectRowOnClick: boolean): this {\n    return this._selectRowOnClick(selectRowOnClick);\n  }\n\n}\n\nexport class CustomValueColumnModel<Row, V> extends ColumnModel<Row> {\n\n  constructor(columnId: string, defaults: ColumnModel.TextPropertiesProvider, private getValue: (row: Row) => V) {\n    super(columnId, defaults);\n    this.cellRenderer(DefaultCellRendererComponent);\n  }\n\n  cellRenderer<C extends { value: Partial<V> }>(componentType: ComponentType<C>, onComponentInitOrOptions?: CellRendererOptions<Row, C> | OnComponentInit<C>): this {\n    this.configureCellRenderer(new ComponentCellRendererPortalRef(componentType, (component, rowData, firstTime) => {\n      if (firstTime) {\n        if (isFunction(onComponentInitOrOptions)) {\n          onComponentInitOrOptions(component);\n        } else {\n          if (isFunction(onComponentInitOrOptions?.onComponentInit)) {\n            onComponentInitOrOptions.onComponentInit(component);\n          }\n        }\n      }\n      component.value = this.getValue(rowData.row);\n\n      if (!isFunction(onComponentInitOrOptions) && isFunction(onComponentInitOrOptions?.onRowUpdate)) {\n        onComponentInitOrOptions.onRowUpdate(component, rowData.row);\n      }\n    }));\n    return this;\n  }\n\n  public selectRowOnClick(selectOnRowClick: boolean): this {\n    return this._selectRowOnClick(selectOnRowClick);\n  }\n\n}\n\nexport class EditorControlColumnModel<Row> extends ColumnModel<Row> {\n\n  constructor(columnId: string, saveCommandFactory: Command.Factory<DirtyTrackingForm<Row>, boolean | Promise<boolean>>, defaults: ColumnModel.TextPropertiesProvider) {\n    super(columnId, defaults);\n    this.cellRenderer(EditRowControls);\n  }\n\n  cellRenderer(componentType: ComponentType<{ row: Row, editSession: EditSession<Row>, editRowCommand: Command<void> }>): this {\n    this.configureCellRenderer(new ComponentCellRendererPortalRef(componentType, (component, rowData: RowData<Row>) => {\n      component.row = rowData.row;\n      component.editSession = rowData.editSession;\n      component.editRowCommand = rowData.editRowCommand;\n    }));\n    return this;\n  }\n\n  protected getDefaultHeaderText(): string {\n    return '';\n  }\n}\n\nexport class CustomTemplateColumnModel<Row> extends ColumnModel<Row> {\n  private readonly config = new TemplateCellRendererPortalRef<Row>();\n\n  constructor(columnId: string, defaults: ColumnModel.TextPropertiesProvider) {\n    super(columnId, defaults);\n    this.configureCellRenderer(this.config);\n  }\n\n  setTemplate(templateRef: TemplateRef<any>, viewContainer: ViewContainerRef, fillCell: boolean, padChild: boolean) {\n    this.config.registerPortal(templateRef, viewContainer, fillCell, padChild);\n  }\n\n  public selectRowOnClick(selectOnRowClick: boolean): this {\n    return this._selectRowOnClick(selectOnRowClick);\n  }\n\n}\n\nexport class SelectionColumnModel<Row> extends ColumnModel<Row> {\n\n  private _enableHeaderControls = true;\n  readonly selectionModel = DelegatingSelectionModel.createDelegate<Row, unknown>();\n\n  constructor(columnId: string, defaults: ColumnModel.TextPropertiesProvider, selectionModel: SelectionModel<Row>) {\n    super(columnId, defaults);\n    this._selectRowOnClick(false);\n    this.cellHeaderRenderer(SelectHeaderCellRendererComponent, (component) => {\n      component.selectionModel = this.selectionModel;\n      component.enableHeaderControls = this._enableHeaderControls;\n    });\n    this.configureCellRenderer(new ComponentCellRendererPortalRef(SelectCellRendererComponent, (component, rowData: RowData<Row>) => {\n      component.row = rowData.row;\n      component.selectionModel = this.selectionModel;\n    }));\n    this.setSelectionModel(selectionModel);\n  }\n\n  setSelectionModel(selectionModel: SelectionModel<Row>) {\n    this.selectionModel.setDelegate(selectionModel);\n    this.setDefaultVisibility(selectionModel instanceof MultipleSelectionModel ? ValueModel.TRUE : ValueModel.FALSE);\n  }\n\n  protected getDefaultHeaderText(): string {\n    return '';\n  }\n\n  enableHeaderControls(enable: boolean): this {\n    this._enableHeaderControls = enable;\n    return this;\n  }\n\n  selectRow(row: Row) {\n    this.selectionModel.selectCommand.execute(row);\n  }\n\n  isSelected(row: Row) {\n    return this.selectionModel.isSelected(row);\n  }\n}\n\n\n"]}

package/esm2020/lib/components/tables/table/column-template/column-template.directive.mjs

@@ -0,0 +1,35 @@
+import { Directive, Input, TemplateRef, ViewContainerRef } from '@angular/core';
+import { assert } from '@coolon/pectin';
+import { AbstractTableComponent } from '../../abstract-table.component';
+import * as i0 from "@angular/core";
+import * as i1 from "../../abstract-table.component";
+export class ColumnTemplateDirective {
+    constructor(host, templateRef, viewContainer) {
+        this.host = host;
+        this.templateRef = templateRef;
+        this.viewContainer = viewContainer;
+        this.aupColumnTemplateFillCell = false;
+        this.aupColumnTemplateAutoPadChild = undefined;
+    }
+    ngOnInit() {
+        assert.isTruthy(this.aupColumnTemplateColumnId);
+        this.host.registerColumnTemplate(this.aupColumnTemplateColumnId, this.templateRef, this.viewContainer, this.aupColumnTemplateFillCell, this.aupColumnTemplateAutoPadChild ?? this.aupColumnTemplateFillCell);
+    }
+}
+ColumnTemplateDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: ColumnTemplateDirective, deps: [{ token: i1.AbstractTableComponent }, { token: i0.TemplateRef }, { token: i0.ViewContainerRef }], target: i0.ɵɵFactoryTarget.Directive });
+ColumnTemplateDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.2.3", type: ColumnTemplateDirective, selector: "[aupColumnTemplate]", inputs: { aupColumnTemplate: "aupColumnTemplate", aupColumnTemplateColumnId: "aupColumnTemplateColumnId", aupColumnTemplateFillCell: "aupColumnTemplateFillCell", aupColumnTemplateAutoPadChild: "aupColumnTemplateAutoPadChild" }, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: ColumnTemplateDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[aupColumnTemplate]'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.AbstractTableComponent }, { type: i0.TemplateRef }, { type: i0.ViewContainerRef }]; }, propDecorators: { aupColumnTemplate: [{
+                type: Input
+            }], aupColumnTemplateColumnId: [{
+                type: Input
+            }], aupColumnTemplateFillCell: [{
+                type: Input
+            }], aupColumnTemplateAutoPadChild: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/components/tables/table/default-cell-renderer/default-cell-renderer.component.mjs

@@ -0,0 +1,22 @@
+import { Component, Input } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "../../../../directives/highlight.pipe";
+export class DefaultCellRendererComponent {
+    constructor() {
+    }
+    set value(value) {
+        this._value = value;
+    }
+    get value() {
+        return this._value;
+    }
+}
+DefaultCellRendererComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: DefaultCellRendererComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+DefaultCellRendererComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.3", type: DefaultCellRendererComponent, selector: "aup-default-cell-renderer", inputs: { value: "value" }, ngImport: i0, template: "<span [innerHTML]=\"value| aupHighlight\"></span>\n", styles: [""], pipes: { "aupHighlight": i1.HighlightPipe } });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: DefaultCellRendererComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'aup-default-cell-renderer', template: "<span [innerHTML]=\"value| aupHighlight\"></span>\n", styles: [""] }]
+        }], ctorParameters: function () { return []; }, propDecorators: { value: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGVmYXVsdC1jZWxsLXJlbmRlcmVyLmNvbXBvbmVudC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvYW5ndWxhci11aS1wb3dlcnVwcy9zcmMvbGliL2NvbXBvbmVudHMvdGFibGVzL3RhYmxlL2RlZmF1bHQtY2VsbC1yZW5kZXJlci9kZWZhdWx0LWNlbGwtcmVuZGVyZXIuY29tcG9uZW50LnRzIiwiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9hbmd1bGFyLXVpLXBvd2VydXBzL3NyYy9saWIvY29tcG9uZW50cy90YWJsZXMvdGFibGUvZGVmYXVsdC1jZWxsLXJlbmRlcmVyL2RlZmF1bHQtY2VsbC1yZW5kZXJlci5jb21wb25lbnQuaHRtbCJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsU0FBUyxFQUFFLEtBQUssRUFBRSxNQUFNLGVBQWUsQ0FBQzs7O0FBU2pELE1BQU0sT0FBTyw0QkFBNEI7SUFZdkM7SUFDQSxDQUFDO0lBVkQsSUFDSSxLQUFLLENBQUMsS0FBUTtRQUNoQixJQUFJLENBQUMsTUFBTSxHQUFHLEtBQUssQ0FBQztJQUN0QixDQUFDO0lBRUQsSUFBSSxLQUFLO1FBQ1AsT0FBTyxJQUFJLENBQUMsTUFBTSxDQUFDO0lBQ3JCLENBQUM7O3lIQVZVLDRCQUE0Qjs2R0FBNUIsNEJBQTRCLDZGQ1R6QyxxREFDQTsyRkRRYSw0QkFBNEI7a0JBTHhDLFNBQVM7K0JBQ0UsMkJBQTJCOzBFQVFqQyxLQUFLO3NCQURSLEtBQUsiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBDb21wb25lbnQsIElucHV0IH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBDZWxsUmVuZGVyZXIgfSBmcm9tICcuLi9jZWxsLXJlbmRlcmVyJztcblxuXG5AQ29tcG9uZW50KHtcbiAgc2VsZWN0b3I6ICdhdXAtZGVmYXVsdC1jZWxsLXJlbmRlcmVyJyxcbiAgdGVtcGxhdGVVcmw6ICcuL2RlZmF1bHQtY2VsbC1yZW5kZXJlci5jb21wb25lbnQuaHRtbCcsXG4gIHN0eWxlVXJsczogWycuL2RlZmF1bHQtY2VsbC1yZW5kZXJlci5jb21wb25lbnQuc2NzcyddXG59KVxuZXhwb3J0IGNsYXNzIERlZmF1bHRDZWxsUmVuZGVyZXJDb21wb25lbnQ8VD4gaW1wbGVtZW50cyBDZWxsUmVuZGVyZXI8VD57XG4gIHByaXZhdGUgX3ZhbHVlOiBUO1xuXG4gIEBJbnB1dCgpXG4gIHNldCB2YWx1ZSh2YWx1ZTogVCkge1xuICAgIHRoaXMuX3ZhbHVlID0gdmFsdWU7XG4gIH1cblxuICBnZXQgdmFsdWUoKTogVCB7XG4gICAgcmV0dXJuIHRoaXMuX3ZhbHVlO1xuICB9XG5cbiAgY29uc3RydWN0b3IoKSB7XG4gIH1cbn1cbiIsIjxzcGFuIFtpbm5lckhUTUxdPVwidmFsdWV8IGF1cEhpZ2hsaWdodFwiPjwvc3Bhbj5cbiJdfQ==

package/esm2020/lib/components/tables/table/default-header-cell-renderer/default-header-cell-renderer.component.mjs

@@ -0,0 +1,15 @@
+import { Component, Input } from '@angular/core';
+import * as i0 from "@angular/core";
+export class DefaultHeaderCellRendererComponent {
+    constructor() {
+    }
+}
+DefaultHeaderCellRendererComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: DefaultHeaderCellRendererComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+DefaultHeaderCellRendererComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.3", type: DefaultHeaderCellRendererComponent, selector: "aup-default-header-renderer", inputs: { headerText: "headerText" }, ngImport: i0, template: "{{headerText}}\n", styles: [""] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: DefaultHeaderCellRendererComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'aup-default-header-renderer', template: "{{headerText}}\n", styles: [""] }]
+        }], ctorParameters: function () { return []; }, propDecorators: { headerText: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGVmYXVsdC1oZWFkZXItY2VsbC1yZW5kZXJlci5jb21wb25lbnQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL2FuZ3VsYXItdWktcG93ZXJ1cHMvc3JjL2xpYi9jb21wb25lbnRzL3RhYmxlcy90YWJsZS9kZWZhdWx0LWhlYWRlci1jZWxsLXJlbmRlcmVyL2RlZmF1bHQtaGVhZGVyLWNlbGwtcmVuZGVyZXIuY29tcG9uZW50LnRzIiwiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9hbmd1bGFyLXVpLXBvd2VydXBzL3NyYy9saWIvY29tcG9uZW50cy90YWJsZXMvdGFibGUvZGVmYXVsdC1oZWFkZXItY2VsbC1yZW5kZXJlci9kZWZhdWx0LWhlYWRlci1jZWxsLXJlbmRlcmVyLmNvbXBvbmVudC5odG1sIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxTQUFTLEVBQUUsS0FBSyxFQUFFLE1BQU0sZUFBZSxDQUFDOztBQU9qRCxNQUFNLE9BQU8sa0NBQWtDO0lBSzdDO0lBQ0EsQ0FBQzs7K0hBTlUsa0NBQWtDO21IQUFsQyxrQ0FBa0MseUdDUC9DLGtCQUNBOzJGRE1hLGtDQUFrQztrQkFMOUMsU0FBUzsrQkFDRSw2QkFBNkI7MEVBT3ZDLFVBQVU7c0JBRFQsS0FBSyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IENvbXBvbmVudCwgSW5wdXQgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcblxuQENvbXBvbmVudCh7XG4gIHNlbGVjdG9yOiAnYXVwLWRlZmF1bHQtaGVhZGVyLXJlbmRlcmVyJyxcbiAgdGVtcGxhdGVVcmw6ICcuL2RlZmF1bHQtaGVhZGVyLWNlbGwtcmVuZGVyZXIuY29tcG9uZW50Lmh0bWwnLFxuICBzdHlsZVVybHM6IFsnLi9kZWZhdWx0LWhlYWRlci1jZWxsLXJlbmRlcmVyLmNvbXBvbmVudC5zY3NzJ11cbn0pXG5leHBvcnQgY2xhc3MgRGVmYXVsdEhlYWRlckNlbGxSZW5kZXJlckNvbXBvbmVudCB7XG5cbiAgQElucHV0KClcbiAgaGVhZGVyVGV4dDogc3RyaW5nO1xuXG4gIGNvbnN0cnVjdG9yKCkge1xuICB9XG59XG4iLCJ7e2hlYWRlclRleHR9fVxuIl19

package/esm2020/lib/components/tables/table/edit-row-controls/edit-row-controls.component.mjs

@@ -0,0 +1,55 @@
+import { __decorate, __metadata } from "tslib";
+import { Component, Input } from '@angular/core';
+import { Command, TrackExternal } from '@coolon/pectin';
+import { DisposableComponent } from '../../../disposable-component';
+import { EditSession } from '../../edit-session';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/material/button";
+import * as i2 from "../../../icon/icon.component";
+import * as i3 from "@angular/common";
+import * as i4 from "../../../../directives/command.directive";
+export class EditRowControls extends DisposableComponent {
+    constructor() {
+        super();
+        this.saveCommand = Command.create(async () => {
+            const finished = await this.editSession.saveCommand.execute();
+            if (finished) {
+                this.editSession.dispose();
+            }
+        });
+        this.cancelCommand = Command.create(() => {
+            this.editSession.dispose();
+        }).disableWhile(this.saveCommand.busy);
+    }
+    set editSession(session) {
+        if (session) {
+            session.form.disableWhile(this.saveCommand.busy);
+        }
+        this._session = session;
+    }
+    get editSession() {
+        return this._session;
+    }
+    ngOnInit() {
+    }
+    get form() {
+        return this.editSession?.form;
+    }
+}
+EditRowControls.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: EditRowControls, deps: [], target: i0.ɵɵFactoryTarget.Component });
+EditRowControls.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.3", type: EditRowControls, selector: "aup-row-editor-controls", inputs: { row: "row", editRowCommand: "editRowCommand", editSession: "editSession" }, usesInheritance: true, ngImport: i0, template: "<button *ngIf=\"!editSession\" mat-icon-button [pectinCommand]=\"editRowCommand\" class=\"edit-button\"><aup-icon icon=\"mat:edit\"></aup-icon></button>\n<button *ngIf=\"editSession\" mat-icon-button [pectinCommand]=\"saveCommand\"><aup-icon icon=\"mat:done\"></aup-icon></button>\n<button *ngIf=\"editSession\" mat-icon-button [pectinCommand]=\"cancelCommand\"><aup-icon icon=\"mat:clear\"></aup-icon></button>\n", styles: [":host{display:block;width:80px}.edit-button{visibility:hidden}:host-context(tr:hover) .edit-button{visibility:visible}\n"], components: [{ type: i1.MatButton, selector: "button[mat-button], button[mat-raised-button], button[mat-icon-button],             button[mat-fab], button[mat-mini-fab], button[mat-stroked-button],             button[mat-flat-button]", inputs: ["disabled", "disableRipple", "color"], exportAs: ["matButton"] }, { type: i2.IconComponent, selector: "aup-icon", inputs: ["icon"] }], directives: [{ type: i3.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { type: i4.CommandDirective, selector: "[pectinCommand]", inputs: ["pectinCommand", "commandParameter"] }] });
+__decorate([
+    TrackExternal(),
+    __metadata("design:type", Command)
+], EditRowControls.prototype, "editRowCommand", void 0);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: EditRowControls, decorators: [{
+            type: Component,
+            args: [{ selector: 'aup-row-editor-controls', template: "<button *ngIf=\"!editSession\" mat-icon-button [pectinCommand]=\"editRowCommand\" class=\"edit-button\"><aup-icon icon=\"mat:edit\"></aup-icon></button>\n<button *ngIf=\"editSession\" mat-icon-button [pectinCommand]=\"saveCommand\"><aup-icon icon=\"mat:done\"></aup-icon></button>\n<button *ngIf=\"editSession\" mat-icon-button [pectinCommand]=\"cancelCommand\"><aup-icon icon=\"mat:clear\"></aup-icon></button>\n", styles: [":host{display:block;width:80px}.edit-button{visibility:hidden}:host-context(tr:hover) .edit-button{visibility:visible}\n"] }]
+        }], ctorParameters: function () { return []; }, propDecorators: { row: [{
+                type: Input
+            }], editRowCommand: [{
+                type: Input
+            }], editSession: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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