ngx-mat-multi-sort/index.d.ts

An extension for the angular material table to support multi-sorting.

import * as i0 from '@angular/core';
import { OnInit, OnChanges, ChangeDetectorRef, ElementRef, TemplateRef, ViewContainerRef } from '@angular/core';
import { MatSort, SortDirection, MatSortable, MatSortHeader, MatSortHeaderIntl } from '@angular/material/sort';
import { FocusMonitor } from '@angular/cdk/a11y';
import * as i4 from '@angular/cdk/drag-drop';
import { CdkDragDrop } from '@angular/cdk/drag-drop';
import { BehaviorSubject, Subject } from 'rxjs';
import { DataSource } from '@angular/cdk/collections';
import { PageEvent } from '@angular/material/paginator';
import { OverlayRef, ScrollStrategy, Overlay, ViewportRuler } from '@angular/cdk/overlay';
import * as i1 from '@angular/common';
import * as i2 from '@angular/material/core';
import * as i3 from '@angular/material/divider';
import * as i5 from '@angular/material/icon';
import * as i6 from '@angular/material/checkbox';
import * as i7 from '@angular/material/menu';
import * as i8 from '@angular/material/button';
import * as i9 from '@angular/forms';
import * as i10 from '@angular/material/chips';
import * as i11 from '@angular/material/tooltip';
import * as i12 from '@angular/material/dialog';

declare class MatMultiSort extends MatSort implements OnInit, OnChanges {
    start: "asc" | "desc";
    actives: string[];
    directions: SortDirection[];
    ngOnInit(): void;
    sort(sortable: MatSortable): void;
    updateMultipleSorts(sortable: MatSortable): void;
    isActive(sortable: MatSortable): boolean;
    activeDirection(sortable: MatSortable): 'asc' | 'desc';
    static ɵfac: i0.ɵɵFactoryDeclaration<MatMultiSort, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<MatMultiSort, "[matMultiSort]", ["matMultiSort"], {}, {}, never, never, true, never>;
}

/** Column definition associated with a `MatSortHeader`. */
interface C2MatSortHeaderColumnDef {
    name: string;
}
declare class MatMultiSortHeaderComponent extends MatSortHeader {
    _intl: MatSortHeaderIntl;
    _sort: MatMultiSort;
    _columnDef: C2MatSortHeaderColumnDef;
    start: "asc" | "desc";
    id: string;
    constructor(_intl: MatSortHeaderIntl, changeDetectorRef: ChangeDetectorRef, _sort: MatMultiSort, _columnDef: C2MatSortHeaderColumnDef, _focusMonitor: FocusMonitor, _elementRef: ElementRef<HTMLElement>);
    _disableViewStateAnimation: boolean;
    _isSorted(): boolean;
    _sortId(): number;
    _renderArrow(): boolean;
    getSortDirection(): 'asc' | 'desc' | '';
    _getArrowViewState(): undefined;
    _getArrowDirectionState(): undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<MatMultiSortHeaderComponent, [null, null, { optional: true; }, { optional: true; }, null, null]>;
    static ɵcmp: i0.ɵɵComponentDeclaration<MatMultiSortHeaderComponent, "[mat-multi-sort-header]", ["matMultiSortHeader"], { "id": { "alias": "mat-multi-sort-header"; "required": false; }; }, {}, never, ["*"], true, never>;
}

declare class MatMultiSortTableDataSource<T> extends DataSource<T> {
    private _data;
    private clientSideSorting;
    sort: MatMultiSort;
    constructor(sort: MatMultiSort, clientSideSorting?: boolean);
    set data(data: T[]);
    get data(): T[];
    connect(): BehaviorSubject<T[]>;
    disconnect(): void;
    orderData(): void;
    sortData(data: T[], actives: string[], directions: string[]): T[];
    _sortData(d1: T, d2: T, params: string[], dirs: string[]): number;
}

declare class TableData<T> {
    private _dataSource;
    private readonly _columns;
    private _displayedColumns;
    pageSize: number;
    pageIndex: number;
    private _pageSizeOptions;
    private _totalElements;
    private _sortParams;
    private _sortDirs;
    private _key;
    private _nextObservable;
    private _previousObservable;
    private _sizeObservable;
    private _sortObservable;
    private _displayedSortDirs?;
    private _displayedSortParams?;
    private _sortHeadersObservable;
    constructor(columns: {
        id: string;
        name: string;
        isActive?: boolean;
    }[], options?: {
        defaultSortParams?: string[];
        defaultSortDirs?: string[];
        pageSizeOptions?: number[];
        totalElements?: number;
        localStorageKey?: string;
    });
    onSortEvent(): void;
    onPaginationEvent($event: PageEvent): void;
    updateSortHeaders(): void;
    private subscribeSortHeaders;
    private init;
    private _clientSideSort;
    private _isLocalStorageSettingsValid;
    storeTableSettings(): void;
    set totalElements(totalElements: number);
    get totalElements(): number;
    set displayedColumns(displayedColumns: string[]);
    get displayedColumns(): string[];
    set dataSource(dataSource: MatMultiSortTableDataSource<T>);
    get dataSource(): MatMultiSortTableDataSource<T>;
    set data(data: T[]);
    set columns(v: {
        id: string;
        name: string;
        isActive?: boolean;
    }[]);
    onColumnsChange(): BehaviorSubject<{
        id: string;
        name: string;
        isActive?: boolean;
    }[]>;
    updateColumnNames(v: {
        id: string;
        name: string;
    }[]): void;
    get nextObservable(): Subject<void>;
    get previousObservable(): Subject<void>;
    get sizeObservable(): Subject<void>;
    get sortObservable(): Subject<void>;
    get sortParams(): string[];
    get sortDirs(): string[];
    get columns(): {
        id: string;
        name: string;
        isActive?: boolean;
    }[];
    get pageSizeOptions(): number[];
    set sortParams(v: string[]);
    set sortDirs(v: string[]);
}

declare class MatMultiSortTableSettingsComponent<T> implements OnInit {
    private overlay;
    private viewContainerRef;
    private viewportRuler;
    _tableData: TableData<T>;
    sort: {
        id: string;
        name: string;
        direction: string;
    }[];
    overlayRef: OverlayRef;
    private templateRef;
    buttonRef: ElementRef;
    sortIndicatorRef: TemplateRef<{
        direction: string;
        columnName: string;
    }>;
    sortToolTip: string;
    closeDialogOnChoice: boolean;
    scrollStrategy: ScrollStrategy;
    set tableData(tableData: TableData<T>);
    disableSortIndicators: boolean;
    constructor(overlay: Overlay, viewContainerRef: ViewContainerRef, viewportRuler: ViewportRuler);
    ngOnInit(): void;
    openDialog(): void;
    drop(event: CdkDragDrop<string[]>): void;
    toggle(): void;
    dropSort(event: CdkDragDrop<string[]>): void;
    getSort(): {
        id: string;
        name: string;
        direction: string;
    }[];
    remove(id: string): void;
    updateDirection(id: string): void;
    private updateSort;
    static ɵfac: i0.ɵɵFactoryDeclaration<MatMultiSortTableSettingsComponent<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<MatMultiSortTableSettingsComponent<any>, "mat-multi-sort-table-settings", never, { "sortToolTip": { "alias": "sortToolTip"; "required": false; }; "closeDialogOnChoice": { "alias": "closeDialogOnChoice"; "required": false; }; "scrollStrategy": { "alias": "scrollStrategy"; "required": false; }; "tableData": { "alias": "tableData"; "required": false; }; "disableSortIndicators": { "alias": "disableSortIndicators"; "required": false; }; }, {}, ["sortIndicatorRef"], ["*"], true, never>;
}

declare class MatMultiSortModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<MatMultiSortModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<MatMultiSortModule, never, [typeof i1.CommonModule, typeof i2.MatCommonModule, typeof i3.MatDividerModule, typeof i4.DragDropModule, typeof i5.MatIconModule, typeof i6.MatCheckboxModule, typeof i7.MatMenuModule, typeof i8.MatButtonModule, typeof i9.FormsModule, typeof i10.MatChipsModule, typeof i11.MatTooltipModule, typeof i12.MatDialogModule, typeof MatMultiSort, typeof MatMultiSortHeaderComponent, typeof MatMultiSortTableSettingsComponent], never>;
    static ɵinj: i0.ɵɵInjectorDeclaration<MatMultiSortModule>;
}

export { MatMultiSort, MatMultiSortHeaderComponent, MatMultiSortModule, MatMultiSortTableDataSource, MatMultiSortTableSettingsComponent, TableData };