@porscheinformatik/clr-addons 19.6.2 → 19.7.1

package/treetable/enums/selection-type.d.ts

@@ -0,0 +1,4 @@
+export declare enum SelectionType {
+    None = 0,
+    Multi = 1
+}

package/treetable/enums/sort-order.enum.d.ts

@@ -0,0 +1,5 @@
+export declare enum ClrTreetableSortOrder {
+    UNSORTED = 0,
+    ASC = 1,
+    DESC = -1
+}

package/treetable/index.d.ts

@@ -6,3 +6,7 @@ export * from './treetable-placeholder';
 export * from './treetable-action-overflow';
 export * from './treetable.module';
 export * from './renderer';
+export * from './providers';
+export * from './treetable-items';
+export * from './interfaces/comparator.interface';
+export * from './enums/sort-order.enum';

package/treetable/interfaces/comparator.interface.d.ts

@@ -0,0 +1,3 @@
+export interface ClrTreetableComparatorInterface<T> {
+    compare(a: T, b: T): number;
+}

package/treetable/providers/index.d.ts

@@ -0,0 +1,3 @@
+export * from './selection';
+export * from './sort';
+export * from './items';

package/treetable/providers/items.d.ts

@@ -0,0 +1,21 @@
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+export declare class Items<T = any> {
+    private _all;
+    private _displayed;
+    private _change;
+    private readonly _sort;
+    constructor();
+    get all(): T[][];
+    addItems(items: T[]): void;
+    get displayed(): T[][];
+    get change(): Observable<T[][]>;
+    /**
+     * Checks if we don't have data to process yet, to abort early operations
+     */
+    private get uninitialized();
+    private emitChange;
+    private sortItems;
+    static ɵfac: i0.ɵɵFactoryDeclaration<Items<any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<Items<any>>;
+}

package/treetable/providers/selection.d.ts

@@ -0,0 +1,28 @@
+import { Observable } from 'rxjs';
+import { SelectionType } from '../enums/selection-type';
+import * as i0 from "@angular/core";
+export declare class Selection<T> {
+    private _current;
+    private _change;
+    private _allSelected;
+    private _valueCollector;
+    private _selectionType;
+    private _items;
+    constructor();
+    get selectionType(): SelectionType;
+    set selectionType(value: SelectionType);
+    get current(): T[];
+    set current(value: T[]);
+    updateCurrent(value: T[], emit: boolean): void;
+    get change(): Observable<T[]>;
+    get allSelectedChange(): Observable<boolean>;
+    isSelected(item: T): boolean;
+    setSelected(item: T, selected: boolean): void;
+    isAllSelected(): boolean;
+    toggleAll(): void;
+    private selectItem;
+    private deselectItem;
+    private emitChange;
+    static ɵfac: i0.ɵɵFactoryDeclaration<Selection<any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<Selection<any>>;
+}

package/treetable/providers/sort.d.ts

@@ -0,0 +1,27 @@
+import { Observable } from 'rxjs';
+import { ClrTreetableComparatorInterface } from '../interfaces/comparator.interface';
+import * as i0 from "@angular/core";
+export declare class Sort<T> {
+    private _comparator;
+    private _reverse;
+    private _change;
+    constructor();
+    get comparator(): ClrTreetableComparatorInterface<T>;
+    set comparator(value: ClrTreetableComparatorInterface<T>);
+    get reverse(): boolean;
+    set reverse(value: boolean);
+    get change(): Observable<Sort<T>>;
+    /**
+     * Sets a comparator as the current one, or toggles reverse if the comparator is already used. The
+     * optional forceReverse input parameter allows to override that toggling behavior by sorting in
+     * reverse order if `true`.
+     *
+     * @memberof Sort
+     */
+    toggle(sortBy: ClrTreetableComparatorInterface<T>, forceReverse?: boolean): void;
+    clear(): void;
+    compare(a: T, b: T): number;
+    emitChange(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<Sort<any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<Sort<any>>;
+}

package/treetable/renderer/main-renderer.d.ts

@@ -1,14 +1,14 @@
-import { AfterViewChecked, QueryList, AfterContentInit } from '@angular/core';
+import { AfterViewChecked, QueryList, AfterContentInit, OnInit } from '@angular/core';
 import { ClrTreetableColumn } from '../treetable-column';
 import { TreetableHeaderRenderer } from './header-renderer';
 import { TreetableRowRenderer } from './row-renderer';
 import * as i0 from "@angular/core";
-export declare class TreetableMainRenderer implements AfterViewChecked, AfterContentInit {
+export declare class TreetableMainRenderer<T> implements OnInit, AfterViewChecked, AfterContentInit {
     headers: QueryList<TreetableHeaderRenderer>;
     rows: QueryList<TreetableRowRenderer>;
-    columns: QueryList<ClrTreetableColumn>;
+    columns: QueryList<ClrTreetableColumn<T>>;
     private shouldStabilizeColumn;
-    onResize(): void;
+    ngOnInit(): void;
     ngAfterContentInit(): void;
     ngAfterViewChecked(): void;
     /**
@@ -17,6 +17,6 @@ export declare class TreetableMainRenderer implements AfterViewChecked, AfterCon
     private applyColumnClasses;
     private applyMaxWidth;
     private applyMaxWidthOnEachRow;
-    static ɵfac: i0.ɵɵFactoryDeclaration<TreetableMainRenderer, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<TreetableMainRenderer, "clr-treetable", never, {}, {}, ["headers", "rows", "columns"], never, false, never>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TreetableMainRenderer<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TreetableMainRenderer<any>, "clr-treetable", never, {}, {}, ["headers", "rows", "columns"], never, false, never>;
 }

package/treetable/treetable-column.d.ts

@@ -1,5 +1,23 @@
+import { ClrTreetableComparatorInterface } from './interfaces/comparator.interface';
+import { ClrTreetableSortOrder } from './enums/sort-order.enum';
 import * as i0 from "@angular/core";
-export declare class ClrTreetableColumn {
-    static ɵfac: i0.ɵɵFactoryDeclaration<ClrTreetableColumn, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<ClrTreetableColumn, "clr-tt-column", never, {}, {}, never, ["*"], false, never>;
+export declare class ClrTreetableColumn<T> {
+    private readonly _sort;
+    private readonly _cdr;
+    private _sortBy;
+    private _sortOrder;
+    private _sortDirection;
+    get sortBy(): ClrTreetableComparatorInterface<T>;
+    set sortBy(comparator: ClrTreetableComparatorInterface<T>);
+    get sortOrder(): ClrTreetableSortOrder;
+    set sortOrder(value: ClrTreetableSortOrder);
+    get sortDirection(): 'up' | 'down' | null;
+    sortOrderChange: import("@angular/core").OutputEmitterRef<ClrTreetableSortOrder>;
+    constructor();
+    get ariaSort(): "none" | "ascending" | "descending";
+    get sortable(): boolean;
+    sort(reverse?: boolean): void;
+    private listenForSortingChanges;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClrTreetableColumn<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ClrTreetableColumn<any>, "clr-tt-column", never, { "sortBy": { "alias": "clrTtSortBy"; "required": false; }; "sortOrder": { "alias": "clrTtSortOrder"; "required": false; }; }, { "sortOrderChange": "clrTtSortOrderChange"; }, never, ["*"], false, never>;
 }

package/treetable/treetable-items.d.ts

@@ -0,0 +1,18 @@
+import { TrackByFunction } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class TreetableItemsDirective<T> {
+    private readonly _items;
+    private readonly _sort;
+    private readonly _template;
+    private readonly _differs;
+    private readonly _vcr;
+    private readonly _cdr;
+    private _iterableProxy;
+    ttItems: import("@angular/core").WritableSignal<any[]>;
+    get clrTtItems(): T[];
+    set clrTtItems(items: T[]);
+    set trackBy(value: TrackByFunction<T>);
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<TreetableItemsDirective<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TreetableItemsDirective<any>, "[clrTtItems]", never, { "clrTtItems": { "alias": "clrTtItems"; "required": false; }; "trackBy": { "alias": "clrTtItemsTrackBy"; "required": false; }; }, {}, never, never, false, never>;
+}

package/treetable/treetable-row.d.ts

@@ -1,21 +1,34 @@
 import { EventEmitter, OnInit } from '@angular/core';
 import { ClrTreetableActionOverflow } from './treetable-action-overflow';
+import { Selection } from './providers';
+import { SelectionType } from './enums/selection-type';
 import * as i0 from "@angular/core";
-export declare class ClrTreetableRow implements OnInit {
+export declare class ClrTreetableRow<T> implements OnInit {
+    readonly selection: Selection<any>;
+    private readonly _cdr;
+    private readonly _destroyRef;
+    private _selected;
+    shouldAnimate: import("@angular/core").WritableSignal<boolean>;
     expanded: boolean;
     clickable: boolean;
     expandable: boolean;
+    clrTtItem: import("@angular/core").InputSignal<T>;
     hasActionOverflow: EventEmitter<boolean>;
     expandedChange: EventEmitter<boolean>;
+    selectedChanged: EventEmitter<boolean>;
     showActionOverflow: boolean;
     showEmptyActionOverflow: boolean;
     showClickClass: boolean;
     set actionOverflow(actionOverflow: ClrTreetableActionOverflow);
-    constructor();
     ngOnInit(): void;
+    onExpandCollapseClick(): void;
+    toggle(selected?: boolean): void;
     private toggleExpand;
     onRowClick(event: MouseEvent): void;
     onCaretClick(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<ClrTreetableRow, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<ClrTreetableRow, "clr-tt-row", never, { "expanded": { "alias": "clrExpanded"; "required": false; }; "clickable": { "alias": "clrClickable"; "required": false; }; "expandable": { "alias": "clrExpandable"; "required": false; }; }, { "hasActionOverflow": "hasActionOverflow"; "expandedChange": "clrExpandedChange"; }, ["actionOverflow"], ["clr-tt-action-overflow", "clr-tt-cell", "clr-tt-row"], false, never>;
+    get selected(): boolean | string;
+    set selected(value: boolean | string);
+    protected readonly SelectionType: typeof SelectionType;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClrTreetableRow<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ClrTreetableRow<any>, "clr-tt-row", never, { "expanded": { "alias": "clrExpanded"; "required": false; }; "clickable": { "alias": "clrClickable"; "required": false; }; "expandable": { "alias": "clrExpandable"; "required": false; }; "clrTtItem": { "alias": "clrTtItem"; "required": false; "isSignal": true; }; }, { "hasActionOverflow": "hasActionOverflow"; "expandedChange": "clrExpandedChange"; "selectedChanged": "clrTtSelectedChange"; }, ["actionOverflow"], ["clr-tt-action-overflow", "clr-tt-cell", "clr-tt-row"], false, never>;
 }

package/treetable/treetable.d.ts

@@ -1,20 +1,31 @@
-import { OnDestroy, QueryList } from '@angular/core';
+import { AfterViewInit, EventEmitter, QueryList } from '@angular/core';
 import { ClrTreetableRow } from './treetable-row';
+import { SelectionType } from './enums/selection-type';
+import { Selection } from './providers';
+import { TreetableItemsDirective } from './treetable-items';
 import * as i0 from "@angular/core";
-export declare class ClrTreetable implements OnDestroy {
+export declare class ClrTreetable<T> implements AfterViewInit {
+    readonly selection: Selection<T>;
+    private readonly _items;
+    private readonly _destroyRef;
     clrClickableRows: boolean;
     hideHeader: boolean;
-    ttColumns: QueryList<ClrTreetableRow>;
+    set selected(value: T[] | undefined);
+    selectedChanged: EventEmitter<T[]>;
+    ttColumns: QueryList<ClrTreetableRow<T>>;
     empty: boolean;
     hasActionOverflow: boolean;
     private _ttRows;
-    private destroyed$;
-    set ttRows(items: QueryList<ClrTreetableRow>);
+    set ttRows(items: QueryList<ClrTreetableRow<T>>);
+    iterator: QueryList<TreetableItemsDirective<T>>;
+    ngAfterViewInit(): void;
     private initClickableRows;
     private initEmpty;
     private initActionOverflow;
     private setActionOverflow;
-    ngOnDestroy(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<ClrTreetable, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<ClrTreetable, "clr-treetable", never, { "clrClickableRows": { "alias": "clrClickableRows"; "required": false; }; "hideHeader": { "alias": "clrHideHeader"; "required": false; }; }, {}, ["ttColumns", "ttRows"], ["clr-tt-column", "clr-tt-row", "clr-tt-placeholder"], false, never>;
+    get allSelected(): boolean;
+    set allSelected(_: boolean);
+    protected readonly SelectionType: typeof SelectionType;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClrTreetable<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ClrTreetable<any>, "clr-treetable", never, { "clrClickableRows": { "alias": "clrClickableRows"; "required": false; }; "hideHeader": { "alias": "clrHideHeader"; "required": false; }; "selected": { "alias": "clrTtSelected"; "required": false; }; }, { "selectedChanged": "clrTtSelectedChange"; }, ["ttColumns", "ttRows", "iterator"], ["clr-tt-column", "clr-tt-row", "clr-tt-placeholder"], false, never>;
 }

package/treetable/treetable.module.d.ts

@@ -9,10 +9,12 @@ import * as i7 from "./renderer/main-renderer";
 import * as i8 from "./renderer/header-renderer";
 import * as i9 from "./renderer/row-renderer";
 import * as i10 from "./renderer/cell-renderer";
-import * as i11 from "@angular/common";
-import * as i12 from "@clr/angular";
+import * as i11 from "./treetable-items";
+import * as i12 from "@angular/common";
+import * as i13 from "@clr/angular";
+import * as i14 from "@angular/forms";
 export declare class ClrTreetableModule {
     static ɵfac: i0.ɵɵFactoryDeclaration<ClrTreetableModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<ClrTreetableModule, [typeof i1.ClrTreetable, typeof i2.ClrTreetableRow, typeof i3.ClrTreetableCell, typeof i4.ClrTreetableColumn, typeof i5.ClrTreetablePlaceholder, typeof i6.ClrTreetableActionOverflow, typeof i7.TreetableMainRenderer, typeof i8.TreetableHeaderRenderer, typeof i9.TreetableRowRenderer, typeof i10.TreetableCellRenderer], [typeof i11.CommonModule, typeof i12.ClarityModule], [typeof i1.ClrTreetable, typeof i2.ClrTreetableRow, typeof i3.ClrTreetableCell, typeof i4.ClrTreetableColumn, typeof i5.ClrTreetablePlaceholder, typeof i6.ClrTreetableActionOverflow, typeof i7.TreetableMainRenderer, typeof i8.TreetableHeaderRenderer, typeof i9.TreetableRowRenderer, typeof i10.TreetableCellRenderer]>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ClrTreetableModule, [typeof i1.ClrTreetable, typeof i2.ClrTreetableRow, typeof i3.ClrTreetableCell, typeof i4.ClrTreetableColumn, typeof i5.ClrTreetablePlaceholder, typeof i6.ClrTreetableActionOverflow, typeof i7.TreetableMainRenderer, typeof i8.TreetableHeaderRenderer, typeof i9.TreetableRowRenderer, typeof i10.TreetableCellRenderer, typeof i11.TreetableItemsDirective], [typeof i12.CommonModule, typeof i13.ClarityModule, typeof i14.ReactiveFormsModule, typeof i14.FormsModule], [typeof i1.ClrTreetable, typeof i2.ClrTreetableRow, typeof i3.ClrTreetableCell, typeof i4.ClrTreetableColumn, typeof i5.ClrTreetablePlaceholder, typeof i6.ClrTreetableActionOverflow, typeof i7.TreetableMainRenderer, typeof i8.TreetableHeaderRenderer, typeof i9.TreetableRowRenderer, typeof i10.TreetableCellRenderer, typeof i11.TreetableItemsDirective]>;
     static ɵinj: i0.ɵɵInjectorDeclaration<ClrTreetableModule>;
 }