@ctodev/cclibrary-typings/src/lib/core/components/tcc-table/tcc-table.component.d.ts

Library typings for use with CLARC INFINITY

import { EventEmitter, OnInit, TemplateRef, QueryList, WritableSignal, AfterContentInit, ElementRef } from '@angular/core';
import { MatSort } from '@angular/material/sort';
import { MatTable, MatTableDataSource } from '@angular/material/table';
import { TccContextMenu } from '../../../shared/components/tcc-context-menu/tcc-context-menu.component';
import { TccTableCheckboxControllerDirective } from '../../../shared/directives/tcc-table-checkbox-controller/tcc-table-checkbox-controller.directive';
import { TccInfinityScroll, TccInfinityScrollComponent } from '../../../shared/components/tcc-infinity-scroll/tcc-infinity-scroll.component';
import { TccContextMenuServiceNamespace } from '../../../shared/services/tcc-context-menu/tcc-context-menu.service';
import { TccClarcDateFormat, TccClarcDatePipe } from '../../../shared/pipes/tcc-clarc-date/tcc-clarc-date.pipe';
import { SpecialColDirective } from './directives/special-col.directive';
import { EditColDirective } from './directives/edit-col.directive';
export declare namespace TccTable {
    interface TableInputs<T> {
        tableOptions: TccTable.TableOptions<T>;
        columnDef: Array<TccTable.ColumnDef<T>>;
    }
    interface TableOptions<T> {
        rowHover: boolean;
        dragAndDrop: boolean;
        sort: sortConfig;
        infinityScroll: infinityScrollConfig;
        classes?: Array<string>;
        checkbox: boolean;
        disabledCheckboxes?: Array<string>;
        contextMenuOptions?: contextMenuConfig;
        placeholder: placeholderConfig;
        density?: tableDensity;
        stickyHeader?: boolean;
        rowSelected?: boolean;
        initSort?: {
            field: string;
            direction: "asc" | "desc";
        };
        editableRows?: boolean;
        deleteConfig?: deleteRowConfig<T>;
        lockRow?: (row: T) => boolean;
    }
    interface ColumnDef<T> {
        id: string;
        path: Array<string>;
        tooltip?: boolean;
        transformFunction?: ((value: any, row?: T) => string);
        useDatePipe?: TccClarcDateFormat;
        useTranslationPipe?: boolean;
        useResolveIdPipe?: boolean;
        ngContent?: ngContentConfig;
        hover?: boolean;
        displayName: string;
        disableSort?: boolean;
        breakCol?: breakColConfig;
        colSize?: cellSize;
        textAlign?: textAlign;
        sortingDataAccessorFunction?: ((value?: any) => string | number);
        editableCol?: editColConfig;
    }
    enum textAlign {
        left = "left",
        center = "center",
        right = "right"
    }
    interface contextMenuConfig {
        MenuOptions: TccContextMenu.option[];
        Name?: string[];
        Id?: string[];
        Delete?: boolean;
        /**
         * If entities can be duplicated.
         * Default: true.
         */
        Duplicate?: boolean;
        GetSelectedEntities?: TccContextMenu.getSelectedEntitiesFunction;
    }
    enum tableDensity {
        density1 = "density1",
        density2 = "density2",
        density3 = "density3",
        density4 = "density4"
    }
    interface sortConfig {
        sortEnabled: boolean;
        sortLocally: boolean;
    }
    interface rowClickEvent {
        rowObject: Object;
        index: number;
        isDoubleClick?: boolean;
    }
    interface checkboxEvent {
        Entity?: Object;
        Value: boolean;
    }
    interface sortTableEvent {
        active: string;
        direction: "asc" | "desc" | "";
    }
    interface infinityScrollConfig {
        enabled: boolean;
        firstElementPath?: Array<string | number>;
        altMode?: boolean;
    }
    interface ngContentConfig {
        enabled: boolean;
        index?: number;
    }
    interface placeholderConfig {
        placeholderText: string;
        placeholderImage: string;
        placeholderImageSize?: placeholderImageSize;
    }
    enum breakColConfig {
        single = "single",
        all = "all"
    }
    enum placeholderImageSize {
        sizeMedium = "mediumSize",
        sizeLarge = "largeSize"
    }
    enum cellSize {
        small = "smallCell",
        medium = "mediumCell",
        large = "largeCell",
        extraLarge = "extraLargeCell"
    }
    interface editColConfig {
        active?: true;
        index?: number;
        onlyCreate?: boolean;
    }
    interface deleteRowConfig<T> {
        enableDeleteButton?: boolean;
        skipCols?: number;
        deleteText?: (entity: T) => string;
    }
}
export declare class TccTableComponent<T> implements OnInit, AfterContentInit {
    private clarcDatePipe;
    specialColumnsList: QueryList<SpecialColDirective>;
    editColumnsList: QueryList<EditColDirective>;
    table: MatTable<any>;
    checkDir: TccTableCheckboxControllerDirective<T>;
    infinityScroll: TccInfinityScrollComponent;
    set content(sort: MatSort);
    tableRows: QueryList<ElementRef<HTMLTableRowElement>>;
    set TableInput(value: TccTable.TableInputs<any>);
    set TableData(value: Array<object>);
    set DisplayedColumns(value: Array<string>);
    _hide: boolean;
    /** sets the table to display: none */
    set hide(value: boolean);
    get hide(): boolean;
    cellClickEmitter: EventEmitter<any>;
    rowClickEmitter: EventEmitter<TccTable.rowClickEvent>;
    scrollDownEmitter: EventEmitter<boolean>;
    checkboxEmitter: EventEmitter<TccTable.checkboxEvent>;
    sortTableEmitter: EventEmitter<TccTable.sortTableEvent>;
    contextMenuEmitter: EventEmitter<TccContextMenuServiceNamespace.contextMenuClickEvent>;
    tableLoadedEmitter: EventEmitter<boolean>;
    rowEditEmitter: EventEmitter<any>;
    deleteRowEmitter: EventEmitter<any>;
    createRowEmitter: EventEmitter<T>;
    createRowAcceptEmitter: EventEmitter<T>;
    createRowDismissEmitter: EventEmitter<T>;
    _tableInput: TccTable.TableInputs<any>;
    _rawData: Array<any & {
        Id: string;
    }>;
    _dataSource: MatTableDataSource<any>;
    _displayedColumns: Array<string>;
    _tableOptions: TccTable.TableOptions<T>;
    _columnDef: Array<TccTable.ColumnDef<any>>;
    tableClasses: Array<string>;
    backupColumns: Array<string>;
    columndef: {
        [columnId: string]: TccTable.ColumnDef<any>;
    };
    selectedRows: string[];
    isSingleClick: boolean;
    selectedRow: string;
    _refreshTransform: number;
    infinityScrollContentType: TccInfinityScroll.contentType;
    specialColumns: Array<TemplateRef<any>>;
    editColumns: Array<TemplateRef<any>>;
    disabledCheckboxesIndex: Array<number>;
    breakColConfig: typeof TccTable.breakColConfig;
    textAlignEnum: typeof TccTable.textAlign;
    editingRow$: WritableSignal<number | null>;
    editBackup: Object;
    creatingRow$: WritableSignal<boolean>;
    deletingRow$: WritableSignal<number | null>;
    constructor(clarcDatePipe: TccClarcDatePipe);
    ngOnInit(): void;
    ngAfterContentInit(): void;
    generateDisplayedColumns(coldef: Array<TccTable.ColumnDef<any>>, displayCols?: Array<string>): void;
    cellClickEvent($event: Object, column: string, row: number, cell: HTMLElement): void;
    rowClickEvent($event: any, isDoubleClick?: boolean, index?: number): void;
    scrollDownEvent($event: boolean): void;
    checkboxEvent($event: {
        Entity: Object;
        Value: boolean;
    } | {
        Value: boolean;
    }): void;
    sortTable($event: {
        active: string;
        direction: "asc" | "desc" | "";
    }): void;
    dropEvent($event: any): void;
    contextMenuOptionClick(event: TccContextMenuServiceNamespace.contextMenuClickEvent): void;
    getCheckedBoxes(): T[];
    getCheckedIndex(): {
        [rowIndex: number]: Object;
    };
    toggleCheckbox(index: number): void;
    filterLocal(filter: any): any[];
    setDisplayedColumns(cols: Array<string>): void;
    refreshTransformedValues(): void;
    checkForSystemEntities(entities: Array<any>): void;
    private buildSortingDataAccessor;
    private getColumnDefById;
    setSelectedRow(id: string): void;
    private objectHasId;
    getSelectedRowIndex(): number;
    editRow(row: number): void;
    editRowAccept(): void;
    editRowDismiss(): void;
    deleteRow(rowIndex: number): void;
    deleteAccept(row: any): void;
    deleteDismiss(): void;
    createRow(): void;
    createRowAccept(row: T): void;
    createRowAccepted(): void;
    createRowDismiss(row: T): void;
    scrollToRow(index: number): void;
    getRowByIndex(index: number): any;
}