@theseam/ui-common 0.2.12 → 0.2.16

package/datatable/datatable-menu-bar/datatable-menu-bar.component.d.ts

@@ -7,7 +7,7 @@ export declare class DatatableMenuBarComponent implements OnInit, AfterViewInit
     set filterDirectives(value: QueryList<DatatableFilterDirective> | undefined);
     private _filterDirectives;
     private _filtersArr;
-    readonly filtersChanged: EventEmitter<IDataFilter[]>;
+    readonly filtersChanged: EventEmitter<import("@theseam/ui-common/data-filters").DataFilter[]>;
     constructor();
     ngOnInit(): void;
     ngAfterViewInit(): void;

package/datatable/directives/datatable-filter.directive.d.ts

@@ -2,5 +2,5 @@ import { IDataFilter } from '@theseam/ui-common/data-filters';
 export declare class DatatableFilterDirective {
     private _filter?;
     constructor(dataFilters: IDataFilter[]);
-    get filter(): IDataFilter | undefined;
+    get filter(): import("@theseam/ui-common/data-filters").DataFilter | undefined;
 }

package/datatable/models/columns-alteration.d.ts

@@ -0,0 +1,61 @@
+import { TheSeamDatatableAccessor } from './datatable-accessor';
+import { TheSeamDatatableColumn } from './table-column';
+export interface ColumnsAlterationState<TState = any> {
+    readonly id: string;
+    readonly type: string;
+    readonly state: TState;
+}
+/**
+ * Alteration applied to a column or columns that can be persisted.
+ *
+ * Tracking if a column was altered by user or library code can be confusing.
+ * This allows us to store a list of replayable alterations on columns. By
+ * having a defined way to implement alterations, the datatable should be easier
+ * to support external features that want to provide an alteration.
+ *
+ * NOTE: Current, to unapply an alteration you can create an alteration with
+ * `persistent` set to false and the alteration will be removed after `apply()`
+ * is called.
+ */
+export declare abstract class ColumnsAlteration<TState = any> {
+    /**
+     * Persistable state.
+     *
+     * Returned value should be JSON stringifyable.
+     */
+    state: TState;
+    /**
+     * If false, the state will not be persisted to a persistent storage and
+     * will be removed after applied.
+     */
+    readonly persistent: boolean;
+    /**
+     * This should be unique to the alteration, but determinable. When an app is
+     * reloaded and alterations are restored from a persistable storage this
+     * should still be recognizable.
+     */
+    abstract readonly id: string;
+    /**
+     * The alteration type.
+     *
+     * This can be used to group alteraction from a common feature.
+     */
+    abstract readonly type: string;
+    constructor(
+    /**
+     * Persistable state.
+     *
+     * Returned value should be JSON stringifyable.
+     */
+    state: TState, 
+    /**
+     * If false, the state will not be persisted to a persistent storage and
+     * will be removed after applied.
+     */
+    persistent: boolean);
+    /**
+     * Apply alteration to column.
+     */
+    abstract apply(columns: TheSeamDatatableColumn[], datatable: TheSeamDatatableAccessor): void;
+    toJSON(): ColumnsAlterationState<TState>;
+}

package/datatable/models/columns-alterations/hide-column.columns-alteration.d.ts

@@ -0,0 +1,15 @@
+import { TableColumnProp } from '@marklb/ngx-datatable';
+import { ColumnsAlteration } from '../columns-alteration';
+import { TheSeamDatatableAccessor } from '../datatable-accessor';
+import { TheSeamDatatableColumn } from '../table-column';
+export interface HideColumnColumnsAlterationState {
+    columnProp: TableColumnProp;
+    hidden: boolean;
+}
+export declare class HideColumnColumnsAlteration extends ColumnsAlteration<HideColumnColumnsAlterationState> {
+    readonly id: string;
+    readonly type: string;
+    constructor(state: HideColumnColumnsAlterationState, persistent: boolean);
+    apply(columns: TheSeamDatatableColumn<any, any>[], datatable: TheSeamDatatableAccessor): void;
+    private _isValidState;
+}

package/datatable/models/columns-alterations/order.columns-alteration.d.ts

@@ -0,0 +1,20 @@
+import { TableColumnProp } from '@marklb/ngx-datatable';
+import { ColumnsAlteration } from '../columns-alteration';
+import { TheSeamDatatableAccessor } from '../datatable-accessor';
+import { TheSeamDatatableColumn } from '../table-column';
+export interface ColumnOrderRecord {
+    columnProp: TableColumnProp;
+    index: number;
+}
+export interface OrderColumnsAlterationState {
+    columns: ColumnOrderRecord[];
+}
+export declare class OrderColumnsAlteration extends ColumnsAlteration<OrderColumnsAlterationState> {
+    readonly id: string;
+    readonly type: string;
+    constructor(state: OrderColumnsAlterationState, persistent: boolean);
+    apply(columns: TheSeamDatatableColumn<any, any>[], datatable: TheSeamDatatableAccessor): void;
+    private _isValidState;
+    private _isColumnOrderRecordValid;
+    private _stateColumns;
+}

package/datatable/models/columns-alterations/sort.columns-alteration.d.ts

@@ -0,0 +1,14 @@
+import { SortItem } from '../sort-item';
+import { ColumnsAlteration } from '../columns-alteration';
+import { TheSeamDatatableAccessor } from '../datatable-accessor';
+import { TheSeamDatatableColumn } from '../table-column';
+export interface SortColumnsAlterationState {
+    sorts: SortItem[];
+}
+export declare class SortColumnsAlteration extends ColumnsAlteration<SortColumnsAlterationState> {
+    readonly id: string;
+    readonly type: string;
+    constructor(state: SortColumnsAlterationState, persistent: boolean);
+    apply(columns: TheSeamDatatableColumn<any, any>[], datatable: TheSeamDatatableAccessor): void;
+    private _isValidState;
+}

package/datatable/models/columns-alterations/width.columns-alteration.d.ts

@@ -0,0 +1,16 @@
+import { TableColumnProp } from '@marklb/ngx-datatable';
+import { ColumnsAlteration } from '../columns-alteration';
+import { TheSeamDatatableAccessor } from '../datatable-accessor';
+import { TheSeamDatatableColumn } from '../table-column';
+export interface WidthColumnsAlterationState {
+    columnProp: TableColumnProp;
+    width?: number;
+    canAutoResize: boolean;
+}
+export declare class WidthColumnsAlteration extends ColumnsAlteration<WidthColumnsAlterationState> {
+    readonly id: string;
+    readonly type: string;
+    constructor(state: WidthColumnsAlterationState, persistent: boolean);
+    apply(columns: TheSeamDatatableColumn<any, any>[], datatable: TheSeamDatatableAccessor): void;
+    private _isValidState;
+}

package/datatable/models/datatable-accessor.d.ts

@@ -1,16 +1,18 @@
 import { Observable } from 'rxjs';
-import { DataFilterState, IDataFilter } from '@theseam/ui-common/data-filters';
+import { DataFilterState, DataFilter } from '@theseam/ui-common/data-filters';
 import { TheSeamPageInfo } from './page-info';
 import { SortEvent } from './sort-event';
 import { SortItem } from './sort-item';
 import { TheSeamDatatableColumn } from './table-column';
+import { SortType } from '@marklb/ngx-datatable';
 export interface TheSeamDatatableAccessor {
     columns: TheSeamDatatableColumn[];
     readonly columns$: Observable<TheSeamDatatableColumn[]>;
     rows: any[];
     readonly rows$: Observable<any[]>;
-    filters: IDataFilter[];
-    readonly filters$: Observable<IDataFilter[]>;
+    filters: DataFilter[];
+    readonly filters$: Observable<DataFilter[]>;
+    sortType: SortType;
     sorts: SortItem[];
     sort: Observable<SortEvent>;
     readonly filterStates: Observable<DataFilterState[]>;

package/datatable/models/internal-column-props.d.ts

@@ -0,0 +1,7 @@
+import { TheSeamDatatableColumn } from './table-column';
+/**
+ * Strings used for columns created and managed
+ * by the datatable.
+ */
+export declare const INTERNAL_COLUMN_PROPS: string[];
+export declare function isInternalColumn(column: TheSeamDatatableColumn): boolean;

package/datatable/models/page-info.d.ts

@@ -1,6 +1,18 @@
 export interface TheSeamPageInfo {
+    /**
+     * Index of page.
+     */
     offset: number;
+    /**
+     * Size of a page.
+     */
     pageSize: number;
+    /**
+     * Max page size.
+     */
     limit?: number;
+    /**
+     * Number of rows.
+     */
     count: number;
 }

package/datatable/models/preferences-accessor.d.ts

@@ -1,5 +1,5 @@
 import { Observable } from 'rxjs';
-export interface ITheSeamDatatablePreferencesAccessor {
+export interface TheSeamDatatablePreferencesAccessor {
     /**
      * Gets a preference.
      */

package/datatable/models/preferences.d.ts

@@ -1,9 +1,17 @@
-export interface ITheSeamDatatablePreferencesColumn {
+import { ColumnsAlterationState } from './columns-alteration';
+export interface TheSeamDatatablePreferencesColumn {
     prop: string;
     width?: number;
     canAutoResize?: boolean;
     hidden?: boolean;
 }
-export interface ITheSeamDatatablePreferences {
-    columns?: ITheSeamDatatablePreferencesColumn[];
+export interface TheSeamDatatablePreferences_v1 {
+    columns?: TheSeamDatatablePreferencesColumn[];
 }
+export interface TheSeamDatatablePreferences_v2 {
+    version: 2;
+    alterations: ColumnsAlterationState[];
+}
+export declare type TheSeamDatatablePreferences = TheSeamDatatablePreferences_v2;
+export declare const CURRENT_DATATABLE_PREFERENCES_VERSION = 2;
+export declare const EMPTY_DATATABLE_PREFERENCES: TheSeamDatatablePreferences;

package/datatable/models/sort-item.d.ts

@@ -1,4 +1,5 @@
+import { TableColumnProp } from '@marklb/ngx-datatable';
 export interface SortItem {
-    prop: string;
+    prop: TableColumnProp;
     dir: 'asc' | 'desc';
 }

package/datatable/services/columns-alterations-manager.service.d.ts

@@ -0,0 +1,39 @@
+import { Observable } from 'rxjs';
+import { ColumnsAlteration } from '../models/columns-alteration';
+import { TheSeamDatatableColumn } from '../models/table-column';
+import { TheSeamDatatableAccessor } from '../models/datatable-accessor';
+export interface ColumnsAlterationsChangedRecord {
+    type: 'added' | 'removed';
+    alteration: ColumnsAlteration;
+}
+export interface ColumnsAlterationsChangedEvent {
+    changes: ColumnsAlterationsChangedRecord[];
+}
+export declare class ColumnsAlterationsManagerService {
+    private readonly _changesSubject;
+    private _alterations;
+    readonly changes: Observable<ColumnsAlterationsChangedEvent>;
+    constructor();
+    get(): ColumnsAlteration[];
+    /**
+     * 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: ColumnsAlteration[], options?: {
+        emitEvent?: boolean;
+    }): ColumnsAlterationsChangedRecord[];
+    remove(alterations: ColumnsAlteration[], options?: {
+        emitEvent?: boolean;
+    }): ColumnsAlterationsChangedRecord[];
+    apply(columns: TheSeamDatatableColumn[], datatable: TheSeamDatatableAccessor): void;
+    clear(options?: {
+        emitEvent?: boolean;
+    }): ColumnsAlterationsChangedRecord[];
+    private _removeNonPersistant;
+    private _emitChanges;
+}

package/datatable/services/columns-manager.service.d.ts

@@ -0,0 +1,55 @@
+import { KeyValueDiffers, TemplateRef } from '@angular/core';
+import { Observable } from 'rxjs';
+import { DataTableColumnCellTreeToggle, DataTableColumnDirective, DataTableColumnHeaderDirective, SelectionType, TableColumn } from '@marklb/ngx-datatable';
+import { DatatableColumnComponent } from '../datatable-column/datatable-column.component';
+import { DatatableRowActionItemDirective } from '../directives/datatable-row-action-item.directive';
+import { TheSeamDatatableColumn } from '../models/table-column';
+import { DatatableColumnChangesService } from './datatable-column-changes.service';
+export declare type InternalColumnsGetter = () => TableColumn[];
+export declare class ColumnsManagerService {
+    private readonly _differs;
+    private readonly _columnChangesService;
+    private readonly _updateColumns;
+    private readonly _inputColumns;
+    private readonly _templateColumns;
+    private readonly _inpColDiffersMap;
+    private readonly _tplColDiffersMap;
+    private readonly _resultColDiffersMap;
+    private _colPropsDiffer?;
+    private _internalColumnsGetter?;
+    private _selectionType;
+    private _rowActionItem;
+    private _actionMenuCellTpl;
+    private _blankHeaderTpl;
+    private _treeToggleTpl;
+    private _headerTpl;
+    private _cellTypeSelectorTpl;
+    readonly columns$: Observable<TheSeamDatatableColumn[]>;
+    constructor(_differs: KeyValueDiffers, _columnChangesService: DatatableColumnChangesService);
+    setInputColumns(columns: TheSeamDatatableColumn[]): void;
+    setTemplateColumns(columns: DatatableColumnComponent[]): void;
+    setInternalColumnsGetter(getter: InternalColumnsGetter | null): void;
+    setSelectionType(selectionType: SelectionType | undefined): void;
+    getSelectionType(): SelectionType | undefined;
+    setRowActionItem(rowActionItem: DatatableRowActionItemDirective | undefined): void;
+    setActionMenuCellTpl(actionMenuCellTpl: TemplateRef<DataTableColumnDirective> | undefined): void;
+    setBlankHeaderTpl(blankHeaderTpl: TemplateRef<DataTableColumnHeaderDirective> | undefined): void;
+    setTreeToggleTpl(treeToggleTpl: TemplateRef<DataTableColumnCellTreeToggle> | undefined): void;
+    setHeaderTpl(headerTpl: TemplateRef<DataTableColumnHeaderDirective> | undefined): void;
+    setCellTypeSelectorTpl(cellTypeSelectorTpl: TemplateRef<DataTableColumnDirective> | undefined): void;
+    private _mergeColumns;
+    private _getInternalColumns;
+    private _getInternalColumn;
+    private _findColumnByProp;
+    private _getDifMapForColumnsType;
+    private _getColumnDiffer;
+    private _getColDif;
+    private _updateColDif;
+    private _hasAddedOrRemovedColumns;
+    private _hasColumnsChanged;
+    private _shouldAddCheckboxColumn;
+    private _shouldAddRowActionColumn;
+    private _shouldAddTreeToggleColumn;
+    private _shouldAddHeaderTemplate;
+    private _shouldAddCellTypeSelectorTpl;
+}

package/datatable/services/datatable-preferences.service.d.ts

@@ -1,19 +1,22 @@
 import { Observable, Subject } from 'rxjs';
-import { ITheSeamDatatablePreferences, ITheSeamDatatablePreferencesColumn } from '../models/preferences';
-import type { ITheSeamDatatablePreferencesAccessor } from '../models/preferences-accessor';
+import { TheSeamDatatablePreferences } from '../models/preferences';
+import type { TheSeamDatatablePreferencesAccessor } from '../models/preferences-accessor';
+import { ColumnsAlterationState } from '../models/columns-alteration';
 export interface IDatatablePreferencesMapRecord {
-    observable: Observable<ITheSeamDatatablePreferences>;
+    observable: Observable<TheSeamDatatablePreferences>;
     refresh: Subject<void>;
 }
 export declare class DatatablePreferencesService {
     private _prefsAccessor?;
     private readonly _tablePrefsMap;
     private _pending;
+    private _loaded;
     get pending(): boolean;
-    constructor(_prefsAccessor?: ITheSeamDatatablePreferencesAccessor | undefined);
-    preferences(preferenceKey: string): Observable<ITheSeamDatatablePreferences>;
+    get loaded(): boolean;
+    constructor(_prefsAccessor?: TheSeamDatatablePreferencesAccessor | undefined);
+    preferences(preferenceKey: string): Observable<TheSeamDatatablePreferences>;
     private _createObservable;
     refresh(preferenceKey: string): void;
-    setColumnPreference(preferenceKey: string, column: ITheSeamDatatablePreferencesColumn): void;
-    withColumnPreferences<T>(preferenceKey: string, columns: T[]): Observable<T[]>;
+    setAlterations(preferenceKey: string, alterations: ColumnsAlterationState[]): void;
+    private _descerializePreferences;
 }

package/datatable/theseam-ui-common-datatable.d.ts

@@ -2,4 +2,6 @@
  * Generated bundle index. Do not edit.
  */
 export * from './public-api';
+export { ColumnsAlterationsManagerService as ɵc } from './services/columns-alterations-manager.service';
+export { ColumnsManagerService as ɵb } from './services/columns-manager.service';
 export { THESEAM_DATATABLE_ACCESSOR as ɵa } from './tokens/datatable-accessor';