@theseam/ui-common 0.3.15-beta.0 → 0.3.15-beta.1

package/esm2020/datatable/services/columns-alterations-manager.service.mjs

@@ -0,0 +1,136 @@
+import { Injectable } from '@angular/core';
+import { Subject } from 'rxjs';
+import { notNullOrUndefined } from '@theseam/ui-common/utils';
+import { HideColumnColumnsAlteration } from '../models/columns-alterations/hide-column.columns-alteration';
+import { SortColumnsAlteration } from '../models/columns-alterations/sort.columns-alteration';
+import { WidthColumnsAlteration } from '../models/columns-alterations/width.columns-alteration';
+import * as i0 from "@angular/core";
+export class ColumnsAlterationsManagerService {
+    constructor() {
+        this._changesSubject = new Subject();
+        this._alterations = [];
+        this.changes = this._changesSubject.asObservable();
+    }
+    get() {
+        return [...this._alterations];
+    }
+    /**
+     * Adds alterations to be applied to columns.
+     *
+     * If an alteration with the same `id` already exists then the existing
+     * alteration will be removed and the new one added.
+     *
+     * NOTE: When there is a duplicate alteration the old alteration is removed,
+     * instead of updated, to maintain the order alterations are applied.
+     */
+    add(alterations, options) {
+        // console.log('add', alterations)
+        const removed = this.remove(alterations, { emitEvent: false });
+        this._alterations = [...this._alterations, ...alterations];
+        const changes = [
+            ...removed,
+            ...alterations.map(a => {
+                const record = {
+                    type: 'added',
+                    alteration: a
+                };
+                return record;
+            })
+        ];
+        if (notNullOrUndefined(options?.emitEvent) && !options?.emitEvent) {
+            return changes;
+        }
+        this._emitChanges(changes);
+        return changes;
+    }
+    remove(alterations, options) {
+        // console.log('remove', alterations)
+        const removed = [];
+        this._alterations = this._alterations.filter(x => {
+            const found = alterations.findIndex(y => y.id === x.id) !== -1;
+            if (found) {
+                const eventRecord = {
+                    type: 'removed',
+                    alteration: x
+                };
+                removed.push(eventRecord);
+            }
+            return !found;
+        });
+        // console.log('removed', removed, this._alterations)
+        if (notNullOrUndefined(options?.emitEvent) && !options?.emitEvent) {
+            return removed;
+        }
+        this._emitChanges(removed);
+        return removed;
+    }
+    apply(columns, datatable) {
+        for (const a of this._alterations) {
+            a.apply(columns, datatable);
+        }
+        this._removeNonPersistant();
+    }
+    // TODO: Make aware of original column order and properties. This is tricky,
+    // because the datatable does not deal with immutable column/row records and
+    // it is hard to know where changes happened. Just serializing the columns
+    // input is not enough, because the columns input is called anytime the user
+    // makes a column change. We can probably come up with a mostly accurate
+    // implementation, such as "reset original columns cache when preferencesKey
+    // changes" or "number of columns change". There are issues with those rules,
+    // but with some testing/experimenting I think there should be a "good enough"
+    // solution.
+    //
+    // TODO: Find a generic way to clear alterations. I would like to add an
+    // `unapply` method to `ColumnsAlteration`, but since the alterations
+    // themselves are not too generic it may be tricky.
+    clear(options) {
+        const changes = [];
+        for (const colAlt of this._alterations) {
+            switch (colAlt.type) {
+                case 'hide-column': {
+                    const alteration = new HideColumnColumnsAlteration({ columnProp: colAlt.state.columnProp, hidden: false }, false);
+                    changes.push(...this.add([alteration]));
+                    break;
+                }
+                case 'order': {
+                    changes.push(...this.remove([colAlt]));
+                    break;
+                }
+                case 'sort': {
+                    const alteration = new SortColumnsAlteration({ sorts: [] }, false);
+                    changes.push(...this.add([alteration]));
+                    break;
+                }
+                case 'width': {
+                    const alteration = new WidthColumnsAlteration({ columnProp: colAlt.state.columnProp, canAutoResize: true }, false);
+                    changes.push(...this.add([alteration]));
+                    break;
+                }
+            }
+        }
+        if (notNullOrUndefined(options?.emitEvent) && !options?.emitEvent) {
+            return changes;
+        }
+        this._emitChanges(changes);
+        return changes;
+    }
+    _removeNonPersistant() {
+        const nonPersistent = this._alterations.filter(x => !x.persistent);
+        this.remove(nonPersistent, { emitEvent: false });
+    }
+    _emitChanges(changes) {
+        if (changes.length === 0) {
+            return;
+        }
+        const event = {
+            changes
+        };
+        this._changesSubject.next(event);
+    }
+}
+ColumnsAlterationsManagerService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: ColumnsAlterationsManagerService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+ColumnsAlterationsManagerService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: ColumnsAlterationsManagerService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: ColumnsAlterationsManagerService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"columns-alterations-manager.service.js","sourceRoot":"","sources":["../../../../../projects/ui-common/datatable/services/columns-alterations-manager.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core'\nimport { Observable, Subject } from 'rxjs'\n\nimport { notNullOrUndefined } from '@theseam/ui-common/utils'\n\nimport { ColumnsAlteration } from '../models/columns-alteration'\nimport { TheSeamDatatableColumn } from '../models/table-column'\nimport { TheSeamDatatableAccessor } from '../models/datatable-accessor'\nimport { HideColumnColumnsAlteration } from '../models/columns-alterations/hide-column.columns-alteration'\nimport { SortColumnsAlteration } from '../models/columns-alterations/sort.columns-alteration'\nimport { WidthColumnsAlteration } from '../models/columns-alterations/width.columns-alteration'\n\nexport interface ColumnsAlterationsChangedRecord {\n  type: 'added' | 'removed'\n  alteration: ColumnsAlteration\n}\n\nexport interface ColumnsAlterationsChangedEvent {\n  changes: ColumnsAlterationsChangedRecord[]\n}\n\n@Injectable()\nexport class ColumnsAlterationsManagerService {\n\n  private readonly _changesSubject = new Subject<ColumnsAlterationsChangedEvent>()\n  private _alterations: ColumnsAlteration[] = []\n\n  public readonly changes: Observable<ColumnsAlterationsChangedEvent>\n\n  constructor() {\n    this.changes = this._changesSubject.asObservable()\n  }\n\n  public get(): ColumnsAlteration[] {\n    return [ ...this._alterations ]\n  }\n\n  /**\n   * Adds alterations to be applied to columns.\n   *\n   * If an alteration with the same `id` already exists then the existing\n   * alteration will be removed and the new one added.\n   *\n   * NOTE: When there is a duplicate alteration the old alteration is removed,\n   * instead of updated, to maintain the order alterations are applied.\n   */\n  public add(alterations: ColumnsAlteration[], options?: { emitEvent?: boolean }): ColumnsAlterationsChangedRecord[] {\n    // console.log('add', alterations)\n    const removed: ColumnsAlterationsChangedRecord[] = this.remove(alterations, { emitEvent: false })\n    this._alterations = [ ...this._alterations, ...alterations ]\n\n    const changes: ColumnsAlterationsChangedRecord[] = [\n      ...removed,\n      ...alterations.map(a => {\n        const record: ColumnsAlterationsChangedRecord = {\n          type: 'added',\n          alteration: a\n        }\n        return record\n      })\n    ]\n\n    if (notNullOrUndefined(options?.emitEvent) && !options?.emitEvent) {\n      return changes\n    }\n\n    this._emitChanges(changes)\n\n    return changes\n  }\n\n  public remove(alterations: ColumnsAlteration[], options?: { emitEvent?: boolean }): ColumnsAlterationsChangedRecord[] {\n    // console.log('remove', alterations)\n    const removed: ColumnsAlterationsChangedRecord[] = []\n    this._alterations = this._alterations.filter(x => {\n      const found = alterations.findIndex(y => y.id === x.id) !== -1\n      if (found) {\n        const eventRecord: ColumnsAlterationsChangedRecord = {\n          type: 'removed',\n          alteration: x\n        }\n        removed.push(eventRecord)\n      }\n      return !found\n    })\n\n    // console.log('removed', removed, this._alterations)\n\n    if (notNullOrUndefined(options?.emitEvent) && !options?.emitEvent) {\n      return removed\n    }\n\n    this._emitChanges(removed)\n\n    return removed\n  }\n\n  public apply(columns: TheSeamDatatableColumn[], datatable: TheSeamDatatableAccessor): void {\n    for (const a of this._alterations) {\n      a.apply(columns, datatable)\n    }\n\n    this._removeNonPersistant()\n  }\n\n  // TODO: Make aware of original column order and properties. This is tricky,\n  // because the datatable does not deal with immutable column/row records and\n  // it is hard to know where changes happened. Just serializing the columns\n  // input is not enough, because the columns input is called anytime the user\n  // makes a column change. We can probably come up with a mostly accurate\n  // implementation, such as \"reset original columns cache when preferencesKey\n  // changes\" or \"number of columns change\". There are issues with those rules,\n  // but with some testing/experimenting I think there should be a \"good enough\"\n  // solution.\n  //\n  // TODO: Find a generic way to clear alterations. I would like to add an\n  // `unapply` method to `ColumnsAlteration`, but since the alterations\n  // themselves are not too generic it may be tricky.\n  public clear(options?: { emitEvent?: boolean }): ColumnsAlterationsChangedRecord[] {\n    const changes: ColumnsAlterationsChangedRecord[] = []\n    for (const colAlt of this._alterations) {\n      switch (colAlt.type) {\n        case 'hide-column': {\n          const alteration = new HideColumnColumnsAlteration({ columnProp: colAlt.state.columnProp, hidden: false }, false)\n          changes.push(...this.add([ alteration ]))\n          break\n        }\n        case 'order': {\n          changes.push(...this.remove([ colAlt ]))\n          break\n        }\n        case 'sort': {\n          const alteration = new SortColumnsAlteration({ sorts: [] }, false)\n          changes.push(...this.add([ alteration ]))\n          break\n        }\n        case 'width': {\n          const alteration = new WidthColumnsAlteration({ columnProp: colAlt.state.columnProp, canAutoResize: true }, false)\n          changes.push(...this.add([ alteration ]))\n          break\n        }\n      }\n    }\n\n    if (notNullOrUndefined(options?.emitEvent) && !options?.emitEvent) {\n      return changes\n    }\n\n    this._emitChanges(changes)\n\n    return changes\n  }\n\n  private _removeNonPersistant(): void {\n    const nonPersistent = this._alterations.filter(x => !x.persistent)\n    this.remove(nonPersistent, { emitEvent: false })\n  }\n\n  private _emitChanges(changes: ColumnsAlterationsChangedRecord[]): void {\n    if (changes.length === 0) {\n      return\n    }\n\n    const event: ColumnsAlterationsChangedEvent = {\n      changes\n    }\n\n    this._changesSubject.next(event)\n  }\n\n}\n"]}

package/esm2020/datatable/services/columns-manager.service.mjs

@@ -0,0 +1,286 @@
+import { Injectable } from '@angular/core';
+import { BehaviorSubject, combineLatest, defer, EMPTY, of, Subject } from 'rxjs';
+import { auditTime, map, shareReplay, startWith, switchMap } from 'rxjs/operators';
+import { SelectionType, } from '@marklb/ngx-datatable';
+import { hasProperty, notNullOrUndefined } from '@theseam/ui-common/utils';
+import { createActionMenuColumn } from '../utils/create-action-menu-column';
+import { createCheckboxColumn } from '../utils/create-checkbox-column';
+import { getColumnProp } from '../utils/get-column-prop';
+import { setColumnDefaults } from '../utils/set-column-defaults';
+import { translateTemplateColumns } from '../utils/translate-templates';
+import * as i0 from "@angular/core";
+import * as i1 from "./datatable-column-changes.service";
+var ColumnsTypes;
+(function (ColumnsTypes) {
+    ColumnsTypes[ColumnsTypes["Input"] = 0] = "Input";
+    ColumnsTypes[ColumnsTypes["Template"] = 1] = "Template";
+    ColumnsTypes[ColumnsTypes["Result"] = 2] = "Result";
+})(ColumnsTypes || (ColumnsTypes = {}));
+export class ColumnsManagerService {
+    constructor(_differs, _columnChangesService) {
+        this._differs = _differs;
+        this._columnChangesService = _columnChangesService;
+        this._updateColumns = new Subject();
+        this._inputColumns = new BehaviorSubject([]);
+        this._templateColumns = new BehaviorSubject([]);
+        this._inpColDiffersMap = new Map();
+        this._tplColDiffersMap = new Map();
+        this._resultColDiffersMap = new Map();
+        const templateColumns$ = this._columnChangesService.columnInputChanges$.pipe(startWith(undefined), switchMap(() => {
+            return this._templateColumns.asObservable().pipe(map(translateTemplateColumns));
+        }));
+        this.columns$ = defer(() => {
+            let isFirst = true;
+            return combineLatest([
+                this._inputColumns.asObservable(),
+                templateColumns$,
+                this._updateColumns.asObservable().pipe(auditTime(0), startWith(undefined))
+            ]).pipe(switchMap(([inputColumns, templateColumns]) => {
+                const cols = this._mergeColumns(inputColumns, templateColumns);
+                const hasColumnsChanged = this._hasColumnsChanged(cols);
+                // TODO: Look for columns added/removed and remove the removed columns
+                // differs, not just changes to columns.
+                const hasAddedOrRemovedColumns = this._hasAddedOrRemovedColumns(cols);
+                // NOTE: Both checks need to be run, even though only one needs to be
+                // true, because their differs need to be called.
+                if (hasColumnsChanged || hasAddedOrRemovedColumns || isFirst) {
+                    isFirst = false;
+                    return of(cols);
+                }
+                return EMPTY;
+            }));
+        }).pipe(shareReplay({ refCount: true, bufferSize: 1 }));
+    }
+    setInputColumns(columns) {
+        this._inputColumns.next(columns);
+    }
+    setTemplateColumns(columns) {
+        this._templateColumns.next(columns);
+    }
+    setInternalColumnsGetter(getter) {
+        this._internalColumnsGetter = getter || undefined;
+        this._updateColumns.next(undefined);
+    }
+    setSelectionType(selectionType) {
+        const changed = this._selectionType !== selectionType;
+        this._selectionType = selectionType;
+        if (changed) {
+            this._updateColumns.next(undefined);
+        }
+    }
+    getSelectionType() {
+        return this._selectionType;
+    }
+    setRowActionItem(rowActionItem) {
+        const changed = this._rowActionItem !== rowActionItem;
+        this._rowActionItem = rowActionItem;
+        if (changed) {
+            this._updateColumns.next(undefined);
+        }
+    }
+    setActionItemColumnPosition(actionItemColumnPosition) {
+        const changed = this._actionItemColumnPosition !== actionItemColumnPosition;
+        this._actionItemColumnPosition = actionItemColumnPosition;
+        if (changed) {
+            this._updateColumns.next(undefined);
+        }
+    }
+    setActionMenuCellTpl(actionMenuCellTpl) {
+        const changed = this._actionMenuCellTpl !== actionMenuCellTpl;
+        this._actionMenuCellTpl = actionMenuCellTpl;
+        if (changed) {
+            this._updateColumns.next(undefined);
+        }
+    }
+    setBlankHeaderTpl(blankHeaderTpl) {
+        const changed = this._blankHeaderTpl !== blankHeaderTpl;
+        this._blankHeaderTpl = blankHeaderTpl;
+        if (changed) {
+            this._updateColumns.next(undefined);
+        }
+    }
+    setTreeToggleTpl(treeToggleTpl) {
+        const changed = this._treeToggleTpl !== treeToggleTpl;
+        this._treeToggleTpl = treeToggleTpl;
+        if (changed) {
+            this._updateColumns.next(undefined);
+        }
+    }
+    setHeaderTpl(headerTpl) {
+        const changed = this._headerTpl !== headerTpl;
+        this._headerTpl = headerTpl;
+        if (changed) {
+            this._updateColumns.next(undefined);
+        }
+    }
+    setCellTypeSelectorTpl(cellTypeSelectorTpl) {
+        const changed = this._cellTypeSelectorTpl !== cellTypeSelectorTpl;
+        this._cellTypeSelectorTpl = cellTypeSelectorTpl;
+        if (changed) {
+            this._updateColumns.next(undefined);
+        }
+    }
+    _mergeColumns(inputColumns, templateColumns) {
+        const cols = [];
+        // Add the first column checkbox if 'checkbox' selection is enabled.
+        if (this._shouldAddCheckboxColumn()) {
+            cols.push(createCheckboxColumn());
+        }
+        // Column needs to be provided in the inputColumns, so iterate the
+        // inputColumns.
+        for (const inpCol of inputColumns) {
+            const prop = getColumnProp(inpCol);
+            if (!notNullOrUndefined(prop)) {
+                throw Error(`Column may have 'prop' or 'name' defined.`);
+            }
+            const internalCol = this._getInternalColumn(prop);
+            const inpColDif = this._getColDif(inpCol, ColumnsTypes.Input);
+            if (notNullOrUndefined(inpColDif)) {
+                this._updateColDif(inpColDif, internalCol, inpCol);
+            }
+            const tplCol = this._findColumnByProp(prop, templateColumns);
+            if (tplCol !== undefined) {
+                const tplColDif = this._getColDif(tplCol, ColumnsTypes.Template);
+                if (notNullOrUndefined(tplColDif)) {
+                    this._updateColDif(tplColDif, internalCol, tplCol);
+                }
+            }
+            const _col = {
+                ...(internalCol || {}),
+                ...inpCol,
+                // TODO: Rethink this, because I don't know if this is correct.
+                ...(tplCol || {})
+            };
+            if (this._shouldAddTreeToggleColumn(_col)) {
+                _col.treeToggleTemplate = this._treeToggleTpl;
+            }
+            if (this._shouldAddHeaderTemplate(_col)) {
+                _col.headerTemplate = this._headerTpl;
+            }
+            if (this._shouldAddCellTypeSelectorTpl(_col)) {
+                _col.cellTemplate = this._cellTypeSelectorTpl;
+            }
+            cols.push(_col);
+        }
+        if (this._shouldAddRowActionColumn()) {
+            const actionMenuColumn = createActionMenuColumn(this._actionMenuCellTpl, this._blankHeaderTpl, this._rowActionColumnIsFrozenLeft(), this._rowActionColumnIsFrozenRight());
+            if (this._rowActionColumnIsStaticLeft()) {
+                cols.unshift(actionMenuColumn);
+            }
+            else {
+                cols.push(actionMenuColumn);
+            }
+        }
+        // Make sure the default for any missing props are set.
+        // TODO: Determine if this should be done earlier, because I don't like
+        // how this is done after dif checks.
+        setColumnDefaults(cols);
+        return cols;
+    }
+    _getInternalColumns() {
+        if (this._internalColumnsGetter === undefined) {
+            return undefined;
+        }
+        return this._internalColumnsGetter();
+    }
+    _getInternalColumn(prop) {
+        const internalCols = this._getInternalColumns();
+        if (internalCols === undefined) {
+            return undefined;
+        }
+        return internalCols.find(c => getColumnProp(c) === prop);
+    }
+    _findColumnByProp(prop, columns) {
+        return columns.find(c => getColumnProp(c) === prop);
+    }
+    _getDifMapForColumnsType(columnsType) {
+        switch (columnsType) {
+            case ColumnsTypes.Input: return this._inpColDiffersMap;
+            case ColumnsTypes.Template: return this._tplColDiffersMap;
+            case ColumnsTypes.Result: return this._resultColDiffersMap;
+        }
+    }
+    _getColumnDiffer(prop, colsType) {
+        const difMap = this._getDifMapForColumnsType(colsType);
+        if (difMap === null) {
+            throw Error(`Invalid columns type.`);
+        }
+        if (!difMap.has(prop)) {
+            difMap.set(prop, this._differs.find({}).create());
+        }
+        const differ = difMap.get(prop);
+        if (differ === undefined) {
+            throw Error(`Differ not found. New differ should have been created.`);
+        }
+        return differ;
+    }
+    _getColDif(col, colsType) {
+        const prop = getColumnProp(col);
+        if (prop === undefined) {
+            throw Error(`Column prop not found.`);
+        }
+        return this._getColumnDiffer(prop, colsType).diff(col);
+    }
+    _updateColDif(colDif, internalColumn, col) {
+        colDif.forEachRemovedItem(r => {
+            if (internalColumn && Object.prototype.hasOwnProperty.call(internalColumn, r.key)) {
+                const k = r.key;
+                delete internalColumn[k];
+            }
+        });
+        colDif.forEachAddedItem(r => col[r.key] = r.currentValue);
+        colDif.forEachChangedItem(r => col[r.key] = r.currentValue);
+    }
+    _hasAddedOrRemovedColumns(columns) {
+        if (!this._colPropsDiffer) {
+            this._colPropsDiffer = this._differs.find([]).create();
+        }
+        const props = columns.map(c => getColumnProp(c));
+        return this._colPropsDiffer.diff(props) !== null;
+    }
+    _hasColumnsChanged(columns) {
+        let colChanged = false;
+        for (const col of columns) {
+            const resultDif = this._getColDif(col, ColumnsTypes.Result);
+            if (resultDif) {
+                // NOTE: Can't return early, because the differs need to be updated.
+                colChanged = true;
+            }
+        }
+        return colChanged;
+    }
+    _shouldAddCheckboxColumn() {
+        return this._selectionType === SelectionType.checkbox;
+    }
+    _shouldAddRowActionColumn() {
+        return this._rowActionItem !== undefined;
+    }
+    _rowActionColumnIsFrozenLeft() {
+        return this._actionItemColumnPosition === 'frozenLeft';
+    }
+    _rowActionColumnIsFrozenRight() {
+        return this._actionItemColumnPosition === 'frozenRight';
+    }
+    _rowActionColumnIsStaticLeft() {
+        return this._actionItemColumnPosition === 'staticLeft';
+    }
+    _rowActionColumnIsStaticRight() {
+        return this._actionItemColumnPosition === 'staticRight';
+    }
+    _shouldAddTreeToggleColumn(column) {
+        return column.isTreeColumn !== undefined && column.isTreeColumn &&
+            (!hasProperty(column, 'treeToggleTemplate') || !notNullOrUndefined(column.treeToggleTemplate));
+    }
+    _shouldAddHeaderTemplate(column) {
+        return !hasProperty(column, 'headerTemplate');
+    }
+    _shouldAddCellTypeSelectorTpl(column) {
+        return hasProperty(column, 'cellType');
+    }
+}
+ColumnsManagerService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: ColumnsManagerService, deps: [{ token: i0.KeyValueDiffers }, { token: i1.DatatableColumnChangesService }], target: i0.ɵɵFactoryTarget.Injectable });
+ColumnsManagerService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: ColumnsManagerService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: ColumnsManagerService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i0.KeyValueDiffers }, { type: i1.DatatableColumnChangesService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"columns-manager.service.js","sourceRoot":"","sources":["../../../../../projects/ui-common/datatable/services/columns-manager.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, KeyValueChanges, KeyValueDiffer, KeyValueDiffers, TemplateRef } from '@angular/core'\nimport { BehaviorSubject, combineLatest, defer, EMPTY, Observable, of, Subject } from 'rxjs'\nimport { auditTime, map, shareReplay, startWith, switchMap } from 'rxjs/operators'\n\nimport {\n  DataTableColumnCellTreeToggle,\n  DataTableColumnDirective,\n  DataTableColumnHeaderDirective,\n  SelectionType,\n  TableColumn,\n  TableColumnProp,\n} from '@marklb/ngx-datatable'\n\nimport { hasProperty, notNullOrUndefined } from '@theseam/ui-common/utils'\n\nimport { DatatableColumnComponent } from '../datatable-column/datatable-column.component'\nimport { DatatableRowActionItemDirective } from '../directives/datatable-row-action-item.directive'\nimport { TheSeamDatatableColumn } from '../models/table-column'\nimport { createActionMenuColumn } from '../utils/create-action-menu-column'\nimport { createCheckboxColumn } from '../utils/create-checkbox-column'\nimport { getColumnProp } from '../utils/get-column-prop'\nimport { setColumnDefaults } from '../utils/set-column-defaults'\nimport { translateTemplateColumns } from '../utils/translate-templates'\nimport { DatatableColumnChangesService } from './datatable-column-changes.service'\nimport { ActionItemColumnPosition } from '../models/action-item-column-position'\n\nenum ColumnsTypes {\n  Input,\n  Template,\n  Result,\n}\n\nexport type InternalColumnsGetter = () => TableColumn[]\n\n@Injectable()\nexport class ColumnsManagerService {\n  private readonly _updateColumns = new Subject<void>()\n\n  private readonly _inputColumns = new BehaviorSubject<TheSeamDatatableColumn[]>([])\n  private readonly _templateColumns = new BehaviorSubject<DatatableColumnComponent[]>([])\n\n  private readonly _inpColDiffersMap = new Map<TableColumnProp, KeyValueDiffer<any, any>>()\n  private readonly _tplColDiffersMap = new Map<TableColumnProp, KeyValueDiffer<any, any>>()\n  private readonly _resultColDiffersMap = new Map<TableColumnProp, KeyValueDiffer<any, any>>()\n  private _colPropsDiffer?: KeyValueDiffer<any, any>\n\n  private _internalColumnsGetter?: InternalColumnsGetter\n\n  private _selectionType: SelectionType | undefined\n  private _rowActionItem: DatatableRowActionItemDirective | undefined\n  private _actionMenuCellTpl: TemplateRef<DataTableColumnDirective> | undefined\n  private _actionItemColumnPosition: ActionItemColumnPosition | undefined\n  private _blankHeaderTpl: TemplateRef<DataTableColumnHeaderDirective> | undefined\n  private _treeToggleTpl: TemplateRef<DataTableColumnCellTreeToggle> | undefined\n  private _headerTpl: TemplateRef<DataTableColumnHeaderDirective> | undefined\n  private _cellTypeSelectorTpl: TemplateRef<DataTableColumnDirective> | undefined\n\n  // TODO: Consider making this a columns changed obervable, to make changes more predictable.\n  public readonly columns$: Observable<TheSeamDatatableColumn[]>\n\n  constructor(\n    private readonly _differs: KeyValueDiffers,\n    private readonly _columnChangesService: DatatableColumnChangesService,\n  ) {\n    const templateColumns$ = this._columnChangesService.columnInputChanges$.pipe(\n      startWith(undefined),\n      switchMap(() => {\n        return this._templateColumns.asObservable().pipe(map(translateTemplateColumns))\n      })\n    )\n\n    this.columns$ = defer(() => {\n      let isFirst = true\n      return combineLatest([\n        this._inputColumns.asObservable(),\n        templateColumns$,\n        this._updateColumns.asObservable().pipe(auditTime(0), startWith(undefined))\n      ]).pipe(\n        switchMap(([ inputColumns, templateColumns ]) => {\n          const cols = this._mergeColumns(inputColumns, templateColumns)\n\n          const hasColumnsChanged = this._hasColumnsChanged(cols)\n\n          // TODO: Look for columns added/removed and remove the removed columns\n          // differs, not just changes to columns.\n          const hasAddedOrRemovedColumns = this._hasAddedOrRemovedColumns(cols)\n\n          // NOTE: Both checks need to be run, even though only one needs to be\n          // true, because their differs need to be called.\n          if (hasColumnsChanged || hasAddedOrRemovedColumns || isFirst) {\n            isFirst = false\n            return of(cols)\n          }\n\n          return EMPTY\n        }),\n      )\n    }).pipe(\n      shareReplay({ refCount: true, bufferSize: 1 })\n    )\n  }\n\n  public setInputColumns(columns: TheSeamDatatableColumn[]): void {\n    this._inputColumns.next(columns)\n  }\n\n  public setTemplateColumns(columns: DatatableColumnComponent[]): void {\n    this._templateColumns.next(columns)\n  }\n\n  public setInternalColumnsGetter(getter: InternalColumnsGetter | null): void {\n    this._internalColumnsGetter = getter || undefined\n    this._updateColumns.next(undefined)\n  }\n\n  public setSelectionType(selectionType: SelectionType | undefined): void {\n    const changed = this._selectionType !== selectionType\n    this._selectionType = selectionType\n    if (changed) {\n      this._updateColumns.next(undefined)\n    }\n  }\n\n  public getSelectionType(): SelectionType | undefined {\n    return this._selectionType\n  }\n\n  public setRowActionItem(rowActionItem: DatatableRowActionItemDirective | undefined): void {\n    const changed = this._rowActionItem !== rowActionItem\n    this._rowActionItem = rowActionItem\n    if (changed) {\n      this._updateColumns.next(undefined)\n    }\n  }\n\n  public setActionItemColumnPosition(actionItemColumnPosition: ActionItemColumnPosition | undefined) {\n    const changed = this._actionItemColumnPosition !== actionItemColumnPosition\n    this._actionItemColumnPosition = actionItemColumnPosition\n    if (changed) {\n      this._updateColumns.next(undefined)\n    }\n  }\n\n  public setActionMenuCellTpl(actionMenuCellTpl: TemplateRef<DataTableColumnDirective> | undefined): void {\n    const changed = this._actionMenuCellTpl !== actionMenuCellTpl\n    this._actionMenuCellTpl = actionMenuCellTpl\n    if (changed) {\n      this._updateColumns.next(undefined)\n    }\n  }\n\n  public setBlankHeaderTpl(blankHeaderTpl: TemplateRef<DataTableColumnHeaderDirective> | undefined): void {\n    const changed = this._blankHeaderTpl !== blankHeaderTpl\n    this._blankHeaderTpl = blankHeaderTpl\n    if (changed) {\n      this._updateColumns.next(undefined)\n    }\n  }\n\n  public setTreeToggleTpl(treeToggleTpl: TemplateRef<DataTableColumnCellTreeToggle> | undefined): void {\n    const changed = this._treeToggleTpl !== treeToggleTpl\n    this._treeToggleTpl = treeToggleTpl\n    if (changed) {\n      this._updateColumns.next(undefined)\n    }\n  }\n\n  public setHeaderTpl(headerTpl: TemplateRef<DataTableColumnHeaderDirective> | undefined): void {\n    const changed = this._headerTpl !== headerTpl\n    this._headerTpl = headerTpl\n    if (changed) {\n      this._updateColumns.next(undefined)\n    }\n  }\n\n  public setCellTypeSelectorTpl(cellTypeSelectorTpl: TemplateRef<DataTableColumnDirective> | undefined): void {\n    const changed = this._cellTypeSelectorTpl !== cellTypeSelectorTpl\n    this._cellTypeSelectorTpl = cellTypeSelectorTpl\n    if (changed) {\n      this._updateColumns.next(undefined)\n    }\n  }\n\n  private _mergeColumns(\n    inputColumns: TheSeamDatatableColumn[],\n    templateColumns: DatatableColumnComponent[]\n  ): TheSeamDatatableColumn[] {\n    const cols: TheSeamDatatableColumn[] = []\n\n    // Add the first column checkbox if 'checkbox' selection is enabled.\n    if (this._shouldAddCheckboxColumn()) {\n      cols.push(createCheckboxColumn())\n    }\n\n    // Column needs to be provided in the inputColumns, so iterate the\n    // inputColumns.\n    for (const inpCol of inputColumns) {\n      const prop = getColumnProp(inpCol)\n      if (!notNullOrUndefined(prop)) {\n        throw Error(`Column may have 'prop' or 'name' defined.`)\n      }\n\n      const internalCol = this._getInternalColumn(prop)\n\n      const inpColDif = this._getColDif(inpCol, ColumnsTypes.Input)\n      if (notNullOrUndefined(inpColDif)) {\n        this._updateColDif(inpColDif, internalCol, inpCol)\n      }\n\n      const tplCol = this._findColumnByProp(prop, templateColumns)\n      if (tplCol !== undefined) {\n        const tplColDif = this._getColDif(tplCol, ColumnsTypes.Template)\n        if (notNullOrUndefined(tplColDif)) {\n          this._updateColDif(tplColDif, internalCol, tplCol)\n        }\n      }\n\n      const _col: TheSeamDatatableColumn = {\n        ...(internalCol || {}),\n        ...inpCol,\n        // TODO: Rethink this, because I don't know if this is correct.\n        ...(tplCol as any || {})\n      }\n\n      if (this._shouldAddTreeToggleColumn(_col)) {\n        _col.treeToggleTemplate = this._treeToggleTpl\n      }\n\n      if (this._shouldAddHeaderTemplate(_col)) {\n        _col.headerTemplate = this._headerTpl\n      }\n\n      if (this._shouldAddCellTypeSelectorTpl(_col)) {\n        _col.cellTemplate = this._cellTypeSelectorTpl\n      }\n\n      cols.push(_col)\n    }\n\n    if (this._shouldAddRowActionColumn()) {\n      const actionMenuColumn = createActionMenuColumn(this._actionMenuCellTpl, this._blankHeaderTpl, this._rowActionColumnIsFrozenLeft(), this._rowActionColumnIsFrozenRight())\n\n      if (this._rowActionColumnIsStaticLeft()) {\n        cols.unshift(actionMenuColumn)\n      } else {\n        cols.push(actionMenuColumn)\n      }\n    }\n\n    // Make sure the default for any missing props are set.\n    // TODO: Determine if this should be done earlier, because I don't like\n    // how this is done after dif checks.\n    setColumnDefaults(cols)\n\n    return cols\n  }\n\n  private _getInternalColumns(): TableColumn[] | undefined {\n    if (this._internalColumnsGetter === undefined) {\n      return undefined\n    }\n\n    return this._internalColumnsGetter()\n  }\n\n  private _getInternalColumn(prop: TableColumnProp): TableColumn | undefined {\n    const internalCols = this._getInternalColumns()\n\n    if (internalCols === undefined) {\n      return undefined\n    }\n\n    return internalCols.find(c => getColumnProp(c) === prop)\n  }\n\n  private _findColumnByProp<T extends TheSeamDatatableColumn | DatatableColumnComponent>(\n    prop: TableColumnProp,\n    columns: T[]\n  ): T | undefined {\n    return columns.find(c => getColumnProp(c) === prop)\n  }\n\n  private _getDifMapForColumnsType(columnsType: ColumnsTypes): Map<TableColumnProp, KeyValueDiffer<any, any>> {\n    switch (columnsType) {\n      case ColumnsTypes.Input: return this._inpColDiffersMap\n      case ColumnsTypes.Template: return this._tplColDiffersMap\n      case ColumnsTypes.Result: return this._resultColDiffersMap\n    }\n  }\n\n  private _getColumnDiffer(prop: TableColumnProp, colsType: ColumnsTypes): KeyValueDiffer<string, any> {\n    const difMap = this._getDifMapForColumnsType(colsType)\n    if (difMap === null) {\n      throw Error(`Invalid columns type.`)\n    }\n\n    if (!difMap.has(prop)) {\n      difMap.set(prop, this._differs.find({}).create())\n    }\n\n    const differ = difMap.get(prop)\n    if (differ === undefined) {\n      throw Error(`Differ not found. New differ should have been created.`)\n    }\n\n    return differ\n  }\n\n  private _getColDif(\n    col: TheSeamDatatableColumn | DatatableColumnComponent,\n    colsType: ColumnsTypes\n  ): KeyValueChanges<string, any> | null {\n    const prop = getColumnProp(col)\n    if (prop === undefined) {\n      throw Error(`Column prop not found.`)\n    }\n\n    return this._getColumnDiffer(prop, colsType).diff(col)\n  }\n\n  private _updateColDif(\n    colDif: KeyValueChanges<string, any>,\n    internalColumn: TableColumn | undefined,\n    col: TheSeamDatatableColumn | DatatableColumnComponent\n  ): void {\n    colDif.forEachRemovedItem(r => {\n      if (internalColumn && Object.prototype.hasOwnProperty.call(internalColumn, r.key)) {\n        const k = r.key as keyof TableColumn\n        delete internalColumn[k]\n      }\n    })\n    colDif.forEachAddedItem(r => (col as any)[r.key] = r.currentValue)\n    colDif.forEachChangedItem(r => (col as any)[r.key] = r.currentValue)\n  }\n\n  private _hasAddedOrRemovedColumns(columns: TheSeamDatatableColumn[]): boolean {\n    if (!this._colPropsDiffer) {\n      this._colPropsDiffer = this._differs.find([]).create()\n    }\n\n    const props = columns.map(c => getColumnProp(c))\n    return this._colPropsDiffer.diff(props) !== null\n  }\n\n  private _hasColumnsChanged(columns: TheSeamDatatableColumn[]): boolean {\n    let colChanged = false\n    for (const col of columns) {\n      const resultDif = this._getColDif(col, ColumnsTypes.Result)\n      if (resultDif) {\n        // NOTE: Can't return early, because the differs need to be updated.\n        colChanged = true\n      }\n    }\n    return colChanged\n  }\n\n  private _shouldAddCheckboxColumn(): boolean {\n    return this._selectionType === SelectionType.checkbox\n  }\n\n  private _shouldAddRowActionColumn(): boolean {\n    return this._rowActionItem !== undefined\n  }\n\n  private _rowActionColumnIsFrozenLeft(): boolean {\n    return this._actionItemColumnPosition === 'frozenLeft'\n  }\n\n  private _rowActionColumnIsFrozenRight(): boolean {\n    return this._actionItemColumnPosition === 'frozenRight'\n  }\n\n  private _rowActionColumnIsStaticLeft(): boolean {\n    return this._actionItemColumnPosition === 'staticLeft'\n  }\n\n  private _rowActionColumnIsStaticRight(): boolean {\n    return this._actionItemColumnPosition === 'staticRight'\n  }\n\n  private _shouldAddTreeToggleColumn(column: TheSeamDatatableColumn): boolean {\n    return column.isTreeColumn !== undefined && column.isTreeColumn &&\n      (!hasProperty(column, 'treeToggleTemplate') || !notNullOrUndefined(column.treeToggleTemplate))\n  }\n\n  private _shouldAddHeaderTemplate(column: TheSeamDatatableColumn): boolean {\n    return !hasProperty(column, 'headerTemplate')\n  }\n\n  private _shouldAddCellTypeSelectorTpl(column: TheSeamDatatableColumn): boolean {\n    return hasProperty(column, 'cellType')\n  }\n\n}\n"]}

package/esm2020/datatable/services/datatable-column-changes.service.mjs

@@ -0,0 +1,20 @@
+import { Injectable } from '@angular/core';
+import { Subject } from 'rxjs';
+import * as i0 from "@angular/core";
+export class DatatableColumnChangesService {
+    constructor() {
+        this.columnInputChanges = new Subject();
+    }
+    get columnInputChanges$() {
+        return this.columnInputChanges.asObservable();
+    }
+    onInputChange() {
+        this.columnInputChanges.next(undefined);
+    }
+}
+DatatableColumnChangesService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: DatatableColumnChangesService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+DatatableColumnChangesService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: DatatableColumnChangesService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: DatatableColumnChangesService, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGF0YXRhYmxlLWNvbHVtbi1jaGFuZ2VzLnNlcnZpY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy91aS1jb21tb24vZGF0YXRhYmxlL3NlcnZpY2VzL2RhdGF0YWJsZS1jb2x1bW4tY2hhbmdlcy5zZXJ2aWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxlQUFlLENBQUE7QUFDMUMsT0FBTyxFQUFjLE9BQU8sRUFBRSxNQUFNLE1BQU0sQ0FBQTs7QUFHMUMsTUFBTSxPQUFPLDZCQUE2QjtJQUQxQztRQUdVLHVCQUFrQixHQUFHLElBQUksT0FBTyxFQUFhLENBQUE7S0FVdEQ7SUFSQyxJQUFJLG1CQUFtQjtRQUNyQixPQUFPLElBQUksQ0FBQyxrQkFBa0IsQ0FBQyxZQUFZLEVBQUUsQ0FBQTtJQUMvQyxDQUFDO0lBRUQsYUFBYTtRQUNYLElBQUksQ0FBQyxrQkFBa0IsQ0FBQyxJQUFJLENBQUMsU0FBUyxDQUFDLENBQUE7SUFDekMsQ0FBQzs7MEhBVlUsNkJBQTZCOzhIQUE3Qiw2QkFBNkI7MkZBQTdCLDZCQUE2QjtrQkFEekMsVUFBVSIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEluamVjdGFibGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJ1xuaW1wb3J0IHsgT2JzZXJ2YWJsZSwgU3ViamVjdCB9IGZyb20gJ3J4anMnXG5cbkBJbmplY3RhYmxlKClcbmV4cG9ydCBjbGFzcyBEYXRhdGFibGVDb2x1bW5DaGFuZ2VzU2VydmljZSB7XG5cbiAgcHJpdmF0ZSBjb2x1bW5JbnB1dENoYW5nZXMgPSBuZXcgU3ViamVjdDx1bmRlZmluZWQ+KClcblxuICBnZXQgY29sdW1uSW5wdXRDaGFuZ2VzJCgpOiBPYnNlcnZhYmxlPHVuZGVmaW5lZD4ge1xuICAgIHJldHVybiB0aGlzLmNvbHVtbklucHV0Q2hhbmdlcy5hc09ic2VydmFibGUoKVxuICB9XG5cbiAgb25JbnB1dENoYW5nZSgpOiB2b2lkIHtcbiAgICB0aGlzLmNvbHVtbklucHV0Q2hhbmdlcy5uZXh0KHVuZGVmaW5lZClcbiAgfVxuXG59XG4iXX0=