@porscheinformatik/clr-addons 19.9.12 → 19.10.0

package/treetable/built-in/filter/treetable-string-filter.d.ts

@@ -0,0 +1,24 @@
+import { ClrTreetableFilterInterface, ClrTreetableStringFilterFunction } from '../../interfaces/filter-model';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+export declare class ClrTreetableStringFilter<T extends object> implements ClrTreetableFilterInterface<T, string> {
+    private readonly smartToggleService;
+    private readonly commonStrings;
+    private readonly elementRef;
+    clrTtStringFilter: import("@angular/core").InputSignal<ClrTreetableStringFilterFunction<T>>;
+    clrTtFilterPlaceholder: import("@angular/core").InputSignal<string>;
+    clrTtFilterLabel: import("@angular/core").InputSignal<string>;
+    clrTtFilterValue: import("@angular/core").ModelSignal<string>;
+    private readonly _input;
+    private readonly _textChange$;
+    protected readonly filterLabel: import("@angular/core").Signal<string>;
+    private readonly initialValue$;
+    readonly changes: Observable<string>;
+    constructor();
+    accepts(item: T): boolean;
+    isActive(): boolean;
+    protected clearFilter(): void;
+    protected inputChanged(value: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClrTreetableStringFilter<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ClrTreetableStringFilter<any>, "clr-tt-string-filter", never, { "clrTtStringFilter": { "alias": "clrTtStringFilter"; "required": true; "isSignal": true; }; "clrTtFilterPlaceholder": { "alias": "clrTtFilterPlaceholder"; "required": false; "isSignal": true; }; "clrTtFilterLabel": { "alias": "clrTtFilterLabel"; "required": false; "isSignal": true; }; "clrTtFilterValue": { "alias": "clrTtFilterValue"; "required": false; "isSignal": true; }; }, { "clrTtFilterValue": "clrTtFilterValueChange"; }, never, never, false, never>;
+}

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

@@ -2,3 +2,8 @@ export declare enum SelectionType {
     None = 0,
     Multi = 1
 }
+export declare enum ClrTreetableSelectedState {
+    UNSELECTED = 0,
+    SELECTED = 1,
+    INDETERMINATE = 2
+}

package/treetable/index.d.ts

@@ -1,6 +1,7 @@
 export * from './treetable';
 export * from './treetable-row';
 export * from './treetable-column';
+export * from './treetable-filter';
 export * from './treetable-cell';
 export * from './treetable-placeholder';
 export * from './treetable-action-overflow';
@@ -8,5 +9,9 @@ export * from './treetable.module';
 export * from './renderer';
 export * from './providers';
 export * from './treetable-items';
+export * from './built-in/filter/treetable-string-filter';
 export * from './interfaces/comparator.interface';
+export * from './interfaces/filter-model';
+export * from './interfaces/treetable-model';
+export * from './interfaces/treetable-state-model';
 export * from './enums/sort-order.enum';

package/treetable/interfaces/filter-model.d.ts

@@ -0,0 +1,37 @@
+import { Observable } from 'rxjs';
+/**
+ * Describes a filter that can be registered with the Treetable.
+ * @template T The type of the item in the treetable.
+ * @template S The type of the filter's value/state (e.g., string, number, etc.).
+ */
+export interface ClrTreetableFilterInterface<T, S = unknown> {
+    /**
+     * An observable that emits whenever the filter's state changes.
+     */
+    readonly changes: Observable<S>;
+    /**
+     * Checks if the filter is currently active.
+     * @returns `true` if the filter is active, otherwise `false`.
+     */
+    isActive(): boolean;
+    /**
+     * Determines if a given item passes the filter's criteria.
+     * @param item The item to test.
+     * @returns `true` if the item is accepted, otherwise `false`.
+     */
+    accepts(item: T): boolean;
+    /**
+     * Checks if the filter is the same as another. Handy for testing.
+     * @param other The filter to test equality against.
+     * @returns `true` if the filters are equal, otherwise `false`.
+     */
+    equals?(other: ClrTreetableFilterInterface<T>): boolean;
+}
+/**
+ * A function type that defines how to filter an item of a Treetable based on a string search value.
+ * @template T The type of the item in the treetable.
+ * @param item The item to be tested against the filter.
+ * @param search The string value used for filtering.
+ * @returns `true` if the item matches the filter criteria, otherwise `false`.
+ */
+export type ClrTreetableStringFilterFunction<T> = (item: T, search: string) => boolean;

package/treetable/interfaces/treetable-model.d.ts

@@ -0,0 +1,55 @@
+import { ClrTreetableSelectedState } from '../enums/selection-type';
+/**
+ * Function type that returns the direct children of a data node.
+ */
+export type ClrTreetableChildrenFunction<T extends object> = (node: T) => Array<T>;
+/**
+ * Represents a single tree node inside the treetable.
+ * Maintains derived selection state (SELECTED / UNSELECTED / INDETERMINATE) based on:
+ *  - Manual selection of this node.
+ *  - Aggregated selection states of all descendants.
+ * Selection propagation to descendants happens only on explicit setSelected calls.
+ */
+export declare class ClrTreetableTreeNode<T extends object> {
+    readonly id: string;
+    readonly value: T;
+    parent: ClrTreetableTreeNode<T> | null;
+    children: ClrTreetableTreeNode<T>[];
+    /**
+     * If true, the node will stay INDETERMINATE even when all descendants are selected
+     * unless it was manually selected.
+     */
+    private readonly stickyIndeterminate;
+    private readonly manuallySelected;
+    selected: import("@angular/core").WritableSignal<ClrTreetableSelectedState>;
+    constructor(value: T, parent?: ClrTreetableTreeNode<T> | null, children?: ClrTreetableTreeNode<T>[], stickyIndeterminate?: boolean);
+    /**
+     * Depth level in the tree (root = 0).
+     */
+    get depth(): number;
+    /**
+     * True if this node has no children.
+     */
+    get isLeaf(): boolean;
+    /**
+     * Sets the selection state for this node and propagates to all descendants (except INDETERMINATE).
+     * @param state Desired selection state.
+     */
+    setSelected(state: ClrTreetableSelectedState): void;
+    /**
+     * Returns all descendants as a flat generator.
+     */
+    getFlatDescendants(): Generator<ClrTreetableTreeNode<T>>;
+    /**
+     * Recursively applies a selected/unselected state to all descendants.
+     */
+    private propagateToChildren;
+}
+/**
+ * Creates an internal tree node hierarchy from a raw data object.
+ *
+ * @param value Root raw data object.
+ * @param getChildren Function returning direct children of a node.
+ * @param stickyIndeterminate Whether to keep INDETERMINATE even if all descendants become selected.
+ */
+export declare function mapToInternalTree<T extends object>(value: T, getChildren: ClrTreetableChildrenFunction<T>, stickyIndeterminate: boolean): ClrTreetableTreeNode<T>;

package/treetable/interfaces/treetable-state-model.d.ts

@@ -0,0 +1,20 @@
+import { ClrTreetableComparatorInterface } from './comparator.interface';
+/**
+ * Represents the current state of the Treetable.
+ *
+ * @template T Type of the data elements.
+ * @template F Type of the filter return value, default is <code>unknown</code>.
+ * @property sort Current sort state or null, if no sort is active.
+ *  - comparator, the comparator used for sorting.
+ *  - reverse true, if it should be sorted in descending order.
+ *  Default: null.
+ * @property filters Array with the current active filter values. Empty if no filters are active.
+ *  Default: [].
+ */
+export interface ClrTreetableState<T, F = unknown> {
+    sort: {
+        comparator: ClrTreetableComparatorInterface<T>;
+        reverse: boolean;
+    } | null;
+    filters: F[];
+}

package/treetable/providers/filters.d.ts

@@ -0,0 +1,29 @@
+import { ClrTreetableFilterInterface } from '../interfaces/filter-model';
+import * as i0 from "@angular/core";
+/**
+ * Wrapper for a treetable filter instance that holds the filter and its unregister callback.
+ *
+ * @template T The row data type processed by the treetable.
+ * @template F The concrete filter type implementing <code>ClrTreetableFilterInterface</code> for <code>T</code>.
+ * @property filter The concrete filter instance.
+ * @property unregister Callback to remove this filter from the Filters service.
+ */
+export declare class RegisteredTreetableFilter<T, F extends ClrTreetableFilterInterface<T>> {
+    filter: F;
+    unregister: () => void;
+    constructor(filter: F, unregister: () => void);
+}
+export declare class Filters<T> {
+    private readonly _destroyRef;
+    private filterId;
+    private readonly updateFilterValue$;
+    private readonly _filterState;
+    private readonly _registeredFilters;
+    readonly activeFilters: import("@angular/core").Signal<ClrTreetableFilterInterface<T, unknown>[]>;
+    readonly hasActiveFilters: import("@angular/core").Signal<boolean>;
+    readonly changes$: import("rxjs").Observable<unknown[]>;
+    constructor();
+    register<F extends ClrTreetableFilterInterface<T>>(treetableFilter: F): RegisteredTreetableFilter<T, F>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<Filters<any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<Filters<any>>;
+}

package/treetable/providers/index.d.ts

@@ -1,3 +1,2 @@
-export * from './selection';
 export * from './sort';
-export * from './items';
+export * from './treetable-data-state.service';

package/treetable/providers/sort.d.ts

@@ -1,27 +1,28 @@
-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>>;
+export interface TreetableSortState<T extends object> {
+    comparator: ClrTreetableComparatorInterface<T> | null;
+    reverse: boolean;
+}
+export declare class Sort<T extends object> {
+    private readonly _comparator;
+    private readonly _reverse;
+    readonly sortState: import("@angular/core").Signal<TreetableSortState<T>>;
+    readonly changes$: import("rxjs").Observable<TreetableSortState<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;
+    /**
+     * Clears the current comparator
+     */
     clear(): void;
+    /**
+     * Compares two items using the current comparator and reverse flag
+     */
     compare(a: T, b: T): number;
-    emitChange(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<Sort<any>, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<Sort<any>>;
 }

package/treetable/providers/treetable-data-state.service.d.ts

@@ -0,0 +1,37 @@
+import { ClrTreetableChildrenFunction, ClrTreetableTreeNode } from '../interfaces/treetable-model';
+import { Observable } from 'rxjs';
+import { ClrTreetableState } from '../interfaces/treetable-state-model';
+import * as i0 from "@angular/core";
+export declare class TreetableDataStateService<T extends object> {
+    private readonly _filters;
+    private readonly _sort;
+    private readonly _dataSource;
+    private readonly _stickyIndeterminate;
+    private readonly _itemsExternallySelected;
+    private readonly _treetableNodes;
+    private readonly _filteredNodes;
+    readonly displayedNodes: import("@angular/core").Signal<ClrTreetableTreeNode<T>[]>;
+    readonly areAllNodesSelected: import("@angular/core").Signal<boolean>;
+    readonly selectedNodes: import("@angular/core").Signal<T[]>;
+    readonly changes$: Observable<ClrTreetableState<T>>;
+    constructor();
+    setDataSource(items: T[], getChildren: ClrTreetableChildrenFunction<T>): void;
+    setExternallySelectedItems(items: T[]): void;
+    setStickyIndeterminate(value: boolean): void;
+    toggleSelectionForDisplayedNodes(): void;
+    private setSelectionForDisplayedNodes;
+    /**
+     * Recursively filters the provided <code>ClrTreetableTreeNodes</code>. It returns the lowest depth nodes of the
+     * provided nodes, that pass all the filters and it's ancestors. The method returns a cloned subset of the provided nodes.
+     *
+     * @param nodes The nodes to filter.
+     * @param activeFilters The currently active filters that have to be passed.
+     * @param parent The parent node to set for the recursive filtering.
+     * @private
+     */
+    private filterTreeRecursively;
+    private sortTreeRecursively;
+    private traverseTreeNodes;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TreetableDataStateService<any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TreetableDataStateService<any>>;
+}

package/treetable/providers/treetable-recursion.service.d.ts

@@ -0,0 +1,17 @@
+import { Optional, TemplateRef } from '@angular/core';
+import { ClrTreetableItemsContext } from '../treetable-items';
+import * as i0 from "@angular/core";
+export declare class ClrTreetableRecursionService<T extends object> {
+    private readonly _template;
+    readonly recursionTemplate: import("@angular/core").Signal<TemplateRef<ClrTreetableItemsContext<T>>>;
+    readonly isRecursionMode: import("@angular/core").Signal<boolean>;
+    setTemplate(newTemplate: TemplateRef<ClrTreetableItemsContext<T>> | null): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClrTreetableRecursionService<any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ClrTreetableRecursionService<any>>;
+}
+export declare function treetableRecursionServiceFactory<T extends object>(existing: ClrTreetableRecursionService<T>): ClrTreetableRecursionService<T>;
+export declare const TREETABLE_RECURSION_SERVICE_PROVIDER: {
+    provide: typeof ClrTreetableRecursionService;
+    useFactory: typeof treetableRecursionServiceFactory;
+    deps: Optional[][];
+};

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

@@ -1,9 +1,9 @@
-import { AfterViewChecked, QueryList, AfterContentInit, OnInit } from '@angular/core';
+import { AfterContentInit, AfterViewChecked, OnInit, QueryList } 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<T> implements OnInit, AfterViewChecked, AfterContentInit {
+export declare class TreetableMainRenderer<T extends object> implements OnInit, AfterViewChecked, AfterContentInit {
     headers: QueryList<TreetableHeaderRenderer>;
     rows: QueryList<TreetableRowRenderer>;
     columns: QueryList<ClrTreetableColumn<T>>;

package/treetable/treetable-action-overflow.d.ts

@@ -1,17 +1,14 @@
-import { NgZone, OnDestroy } from '@angular/core';
+import { NgZone } from '@angular/core';
 import { ClrPopoverPosition, ClrPopoverToggleService } from '@clr/angular';
-import { Subject } from 'rxjs';
 import * as i0 from "@angular/core";
-export declare class ClrTreetableActionOverflow implements OnDestroy {
+export declare class ClrTreetableActionOverflow {
     private smartToggleService;
     private zone;
-    empty: boolean;
+    empty: import("@angular/core").InputSignal<boolean>;
     smartPosition: ClrPopoverPosition;
-    destroyed$: Subject<void>;
     constructor(smartToggleService: ClrPopoverToggleService, zone: NgZone);
     private focusFirstButton;
     closeOverflowContent(event: Event): void;
-    ngOnDestroy(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<ClrTreetableActionOverflow, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<ClrTreetableActionOverflow, "clr-tt-action-overflow", never, { "empty": { "alias": "empty"; "required": false; }; }, {}, never, ["*"], false, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ClrTreetableActionOverflow, "clr-tt-action-overflow", never, { "empty": { "alias": "empty"; "required": false; "isSignal": true; }; }, {}, never, ["*"], false, never>;
 }

package/treetable/treetable-column.d.ts

@@ -1,23 +1,18 @@
 import { ClrTreetableComparatorInterface } from './interfaces/comparator.interface';
 import { ClrTreetableSortOrder } from './enums/sort-order.enum';
 import * as i0 from "@angular/core";
-export declare class ClrTreetableColumn<T> {
+import * as i1 from "@clr/angular";
+export declare class ClrTreetableColumn<T extends object> {
     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>;
+    clrTtSortBy: import("@angular/core").InputSignal<ClrTreetableComparatorInterface<T>>;
+    clrTtSortOrder: import("@angular/core").InputSignal<ClrTreetableSortOrder>;
+    clrTtSortOrderChange: import("@angular/core").OutputEmitterRef<ClrTreetableSortOrder>;
+    private readonly _internalSortOrder;
+    protected readonly isSortable: import("@angular/core").Signal<boolean>;
+    protected readonly sortDirection: import("@angular/core").Signal<"up" | "down">;
+    protected readonly ariaSort: import("@angular/core").Signal<"none" | "ascending" | "descending">;
     constructor();
-    get ariaSort(): "none" | "ascending" | "descending";
-    get sortable(): boolean;
-    sort(reverse?: boolean): void;
-    private listenForSortingChanges;
+    protected sort(reverse?: boolean): void;
     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>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ClrTreetableColumn<any>, "clr-tt-column", never, { "clrTtSortBy": { "alias": "clrTtSortBy"; "required": false; "isSignal": true; }; "clrTtSortOrder": { "alias": "clrTtSortOrder"; "required": false; "isSignal": true; }; }, { "clrTtSortOrderChange": "clrTtSortOrderChange"; }, never, ["clr-tt-filter, clr-tt-string-filter", "*"], false, [{ directive: typeof i1.ClrPopoverHostDirective; inputs: {}; outputs: {}; }]>;
 }

package/treetable/treetable-filter.d.ts

@@ -0,0 +1,18 @@
+import { OnDestroy, OnInit } from '@angular/core';
+import { ClrTreetableFilterInterface } from './interfaces/filter-model';
+import { ClrCommonStringsService, ClrPopoverPosition } from '@clr/angular';
+import * as i0 from "@angular/core";
+export declare class ClrTreetableFilter<T extends object> implements OnInit, OnDestroy {
+    protected readonly commonStringsService: ClrCommonStringsService;
+    private readonly smartToggleService;
+    private readonly filterProvider;
+    protected readonly smartPosition: ClrPopoverPosition;
+    clrTtFilter: import("@angular/core").InputSignal<ClrTreetableFilterInterface<T, unknown>>;
+    private readonly registered;
+    protected readonly open: import("@angular/core").Signal<boolean>;
+    protected readonly active: import("@angular/core").Signal<boolean>;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClrTreetableFilter<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ClrTreetableFilter<any>, "clr-tt-filter", never, { "clrTtFilter": { "alias": "clrTtFilter"; "required": true; "isSignal": true; }; }, {}, never, ["*"], false, never>;
+}

package/treetable/treetable-items.d.ts

@@ -1,18 +1,25 @@
-import { TrackByFunction } from '@angular/core';
+import { ClrTreetableChildrenFunction, ClrTreetableTreeNode } from './interfaces/treetable-model';
 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>);
+/**
+ * Context passed to a TreeTable item template.
+ *
+ * $implicit: The current data item.<br/>
+ * isLeaf: True if the node has no children.<br/>
+ * clrTtNode: Internal tree node metadata object.<br/>
+ */
+export type ClrTreetableItemsContext<T extends object> = {
+    $implicit: T;
+    isLeaf: boolean;
+    clrTtNode: ClrTreetableTreeNode<T>;
+};
+export declare class TreetableItemsDirective<T extends object> {
+    private readonly _dataStateService;
+    private readonly _recursionService;
+    private readonly _templateRef;
+    clrTtItemsOf: import("@angular/core").InputSignal<T[]>;
+    clrTtItemsGetChildren: import("@angular/core").InputSignal<ClrTreetableChildrenFunction<T>>;
     constructor();
+    static ngTemplateContextGuard<C extends object>(dir: TreetableItemsDirective<C>, ctx: any): ctx is ClrTreetableItemsContext<C>;
     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>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TreetableItemsDirective<any>, "[clrTtItems][clrTtItemsOf]", never, { "clrTtItemsOf": { "alias": "clrTtItemsOf"; "required": true; "isSignal": true; }; "clrTtItemsGetChildren": { "alias": "clrTtItemsGetChildren"; "required": true; "isSignal": true; }; }, {}, never, never, false, never>;
 }

package/treetable/treetable-recursive-rows.d.ts

@@ -0,0 +1,12 @@
+import { ClrTreetableTreeNode } from './interfaces/treetable-model';
+import { ClrTreetableItemsContext } from './treetable-items';
+import * as i0 from "@angular/core";
+export declare class ClrTreetableRecursiveRows<T extends object> {
+    private readonly _recursionService;
+    readonly parent: import("@angular/core").InputSignal<ClrTreetableTreeNode<T>>;
+    readonly children: import("@angular/core").InputSignal<ClrTreetableTreeNode<T>[]>;
+    protected readonly template: import("@angular/core").Signal<import("@angular/core").TemplateRef<ClrTreetableItemsContext<any>>>;
+    protected getContext(node: ClrTreetableTreeNode<T>): ClrTreetableItemsContext<T>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClrTreetableRecursiveRows<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ClrTreetableRecursiveRows<any>, "clr-tt-recursive-rows", never, { "parent": { "alias": "parent"; "required": false; "isSignal": true; }; "children": { "alias": "children"; "required": false; "isSignal": true; }; }, {}, never, never, false, never>;
+}

package/treetable/treetable-row-checkbox.d.ts

@@ -0,0 +1,10 @@
+import { ClrTreetableSelectedState } from './enums/selection-type';
+import * as i0 from "@angular/core";
+export declare class ClrTreetableRowCheckbox {
+    clrTtSelectionState: import("@angular/core").ModelSignal<ClrTreetableSelectedState>;
+    protected isSelected: import("@angular/core").Signal<boolean>;
+    protected isIndeterminate: import("@angular/core").Signal<boolean>;
+    protected toggle(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClrTreetableRowCheckbox, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ClrTreetableRowCheckbox, "clr-tt-row-checkbox", never, { "clrTtSelectionState": { "alias": "clrTtSelectionState"; "required": false; "isSignal": true; }; }, { "clrTtSelectionState": "clrTtSelectionStateChange"; }, never, never, false, never>;
+}

package/treetable/treetable-row.d.ts

@@ -1,34 +1,27 @@
-import { EventEmitter, OnInit } from '@angular/core';
-import { ClrTreetableActionOverflow } from './treetable-action-overflow';
-import { Selection } from './providers';
-import { SelectionType } from './enums/selection-type';
+import { ClrTreetableSelectedState } from './enums/selection-type';
+import { ClrTreetableTreeNode } from './interfaces/treetable-model';
 import * as i0 from "@angular/core";
-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);
-    ngOnInit(): void;
-    onExpandCollapseClick(): void;
-    toggle(selected?: boolean): void;
+export declare class ClrTreetableRow<T extends object> {
+    private readonly _recursionService;
+    private readonly _treetable;
+    clrExpanded: import("@angular/core").ModelSignal<boolean>;
+    clrExpandable: import("@angular/core").InputSignal<boolean>;
+    clrClickable: import("@angular/core").InputSignal<boolean>;
+    clrTtItem: import("@angular/core").InputSignal<ClrTreetableTreeNode<T>>;
+    private readonly _actionOverflow;
+    protected readonly shouldAnimate: import("@angular/core").WritableSignal<boolean>;
+    protected readonly isRecursionMode: import("@angular/core").Signal<boolean>;
+    private readonly _isClickable;
+    protected readonly isSelected: import("@angular/core").Signal<boolean>;
+    protected readonly showActionOverflow: import("@angular/core").Signal<boolean>;
+    protected readonly showEmptyActionOverflow: import("@angular/core").Signal<boolean>;
+    protected readonly showClickClass: import("@angular/core").Signal<boolean>;
+    protected readonly showSelection: import("@angular/core").Signal<boolean>;
+    private onExpandCollapseClick;
+    protected toggleSelection(selectionState: ClrTreetableSelectedState): void;
     private toggleExpand;
-    onRowClick(event: MouseEvent): void;
-    onCaretClick(): void;
-    get selected(): boolean | string;
-    set selected(value: boolean | string);
-    protected readonly SelectionType: typeof SelectionType;
+    protected onRowClick(event: MouseEvent): void;
+    protected onCaretClick(): void;
     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>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ClrTreetableRow<any>, "clr-tt-row", never, { "clrExpanded": { "alias": "clrExpanded"; "required": false; "isSignal": true; }; "clrExpandable": { "alias": "clrExpandable"; "required": false; "isSignal": true; }; "clrClickable": { "alias": "clrClickable"; "required": false; "isSignal": true; }; "clrTtItem": { "alias": "clrTtItem"; "required": false; "isSignal": true; }; }, { "clrExpanded": "clrExpandedChange"; }, ["_actionOverflow"], ["clr-tt-action-overflow", "clr-tt-cell", "clr-tt-row"], false, never>;
 }

package/treetable/treetable.d.ts

@@ -1,32 +1,27 @@
-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 { ClrTreetableState } from './interfaces/treetable-state-model';
 import * as i0 from "@angular/core";
-export declare class ClrTreetable<T> implements AfterViewInit {
-    readonly selection: Selection<T>;
-    private readonly _items;
-    private readonly _destroyRef;
-    private readonly cdr;
-    clrClickableRows: boolean;
-    hideHeader: boolean;
-    set selected(value: T[] | undefined);
-    selectedChanged: EventEmitter<T[]>;
-    ttColumns: QueryList<ClrTreetableRow<T>>;
-    empty: boolean;
-    hasActionOverflow: boolean;
-    private _ttRows;
-    set ttRows(items: QueryList<ClrTreetableRow<T>>);
-    iterator: QueryList<TreetableItemsDirective<T>>;
-    ngAfterViewInit(): void;
-    private initClickableRows;
-    private initEmpty;
-    private initActionOverflow;
-    private setActionOverflow;
-    get allSelected(): boolean;
-    set allSelected(_: boolean);
-    protected readonly SelectionType: typeof SelectionType;
+export declare class ClrTreetable<T extends object> {
+    private readonly _dataStateService;
+    private readonly _recursionService;
+    clrClickableRows: import("@angular/core").InputSignal<boolean>;
+    clrHideHeader: import("@angular/core").InputSignal<boolean>;
+    clrTtLoading: import("@angular/core").InputSignal<boolean>;
+    clrTtSelected: import("@angular/core").InputSignal<T[]>;
+    clrTtAutoParentSelection: import("@angular/core").InputSignal<boolean>;
+    clrTtSelectedChange: import("@angular/core").OutputRef<T[]>;
+    clrTtRefresh: import("@angular/core").OutputRef<ClrTreetableState<T, unknown>>;
+    private readonly _ttRows;
+    private readonly _actionOverflow;
+    protected readonly empty: import("@angular/core").Signal<boolean>;
+    protected readonly displayedNodes: import("@angular/core").Signal<import("@porscheinformatik/clr-addons").ClrTreetableTreeNode<T>[]>;
+    protected readonly isRecursionMode: import("@angular/core").Signal<boolean>;
+    readonly selectionType: import("@angular/core").Signal<SelectionType>;
+    readonly showSelection: import("@angular/core").Signal<boolean>;
+    readonly areAllRowsSelected: import("@angular/core").Signal<boolean>;
+    readonly hasActionOverflow: import("@angular/core").Signal<boolean>;
+    constructor();
+    toggleSelectAll(): void;
     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>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ClrTreetable<any>, "clr-treetable", never, { "clrClickableRows": { "alias": "clrClickableRows"; "required": false; "isSignal": true; }; "clrHideHeader": { "alias": "clrHideHeader"; "required": false; "isSignal": true; }; "clrTtLoading": { "alias": "clrTtLoading"; "required": false; "isSignal": true; }; "clrTtSelected": { "alias": "clrTtSelected"; "required": false; "isSignal": true; }; "clrTtAutoParentSelection": { "alias": "clrTtAutoParentSelection"; "required": false; "isSignal": true; }; }, { "clrTtSelectedChange": "clrTtSelectedChange"; "clrTtRefresh": "clrTtRefresh"; }, ["_ttRows", "_actionOverflow"], ["clr-tt-column", "clr-tt-row", "clr-tt-placeholder"], false, never>;
 }

package/treetable/treetable.module.d.ts

@@ -10,11 +10,16 @@ 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 "./treetable-items";
-import * as i12 from "@angular/common";
-import * as i13 from "@clr/angular";
-import * as i14 from "@angular/forms";
+import * as i12 from "./treetable-filter";
+import * as i13 from "./built-in/filter/treetable-string-filter";
+import * as i14 from "./treetable-recursive-rows";
+import * as i15 from "./treetable-row-checkbox";
+import * as i16 from "@angular/common";
+import * as i17 from "@clr/angular";
+import * as i18 from "@angular/forms";
 export declare class ClrTreetableModule {
+    constructor();
     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.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 ɵ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.ClrTreetableFilter, typeof i13.ClrTreetableStringFilter, typeof i14.ClrTreetableRecursiveRows, typeof i15.ClrTreetableRowCheckbox], [typeof i16.CommonModule, typeof i17.ClarityModule, typeof i18.ReactiveFormsModule, typeof i18.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, typeof i12.ClrTreetableFilter, typeof i13.ClrTreetableStringFilter]>;
     static ɵinj: i0.ɵɵInjectorDeclaration<ClrTreetableModule>;
 }