@clr/angular 15.3.0 → 15.5.0

package/data/datagrid/providers/selection.d.ts

@@ -8,65 +8,56 @@ export declare class Selection<T = any> {
     private _filters;
     id: string;
     preserveSelection: boolean;
+    /**
+     * Last selection, for use in range selection.
+     */
+    rangeStart: T;
+    /**
+     * Shift key state, for use in range selection.
+     */
+    shiftPressed: boolean;
+    /** @deprecated since 2.0, remove in 3.0 */
+    rowSelectionMode: boolean;
     private prevSelectionRefs;
     private prevSingleSelectionRef;
     private lockedRefs;
-    constructor(_items: Items<T>, _filters: FiltersProvider<T>);
-    clearSelection(): void;
+    private valueCollector;
     private _selectionType;
-    get selectionType(): SelectionType;
-    set selectionType(value: SelectionType);
-    /** @deprecated since 2.0, remove in 3.0 */
-    rowSelectionMode: boolean;
-    private get _selectable();
-    /**
-     * Subscriptions to the other providers changes.
-     */
-    private subscriptions;
     /**
-     * Cleans up our subscriptions to other providers
+     * The current selection
      */
-    destroy(): void;
+    private _current;
     /**
      * The current selection in single selection type
      */
     private _currentSingle;
-    get currentSingle(): T;
-    set currentSingle(value: T);
     /**
-     * The current selection
+     * The Observable that lets other classes subscribe to selection changes
      */
-    private _current;
-    get current(): T[];
-    set current(value: T[]);
+    private _change;
     /**
-     * Last selection, for use in range selection.
+     * Subscriptions to the other providers changes.
      */
-    rangeStart: T;
+    private subscriptions;
+    constructor(_items: Items<T>, _filters: FiltersProvider<T>);
+    get selectionType(): SelectionType;
+    set selectionType(value: SelectionType);
+    get current(): T[];
+    set current(value: T[]);
+    get currentSingle(): T;
+    set currentSingle(value: T);
+    get change(): Observable<T[] | T>;
+    private get _selectable();
+    clearSelection(): void;
     /**
-     * Shift key state, for use in range selection.
+     * Cleans up our subscriptions to other providers
      */
-    shiftPressed: boolean;
-    private valueCollector;
+    destroy(): void;
     updateCurrent(value: T[], emit: boolean): void;
-    /**
-     * The Observable that lets other classes subscribe to selection changes
-     */
-    private _change;
-    private emitChange;
-    get change(): Observable<T[] | T>;
     /**
      * Checks if an item is currently selected
      */
     isSelected(item: T): boolean;
-    /**
-     * Selects an item
-     */
-    private selectItem;
-    /**
-     * Deselects an item
-     */
-    private deselectItem;
     /**
      * Selects or deselects an item
      */
@@ -75,10 +66,6 @@ export declare class Selection<T = any> {
      * Checks if all currently displayed items are selected
      */
     isAllSelected(): boolean;
-    /**
-     * Make sure that it could be locked
-     */
-    private canItBeLocked;
     /**
      * Lock and unlock item
      */
@@ -91,6 +78,19 @@ export declare class Selection<T = any> {
      * Selects or deselects all currently displayed items
      */
     toggleAll(): void;
+    /**
+     * Selects an item
+     */
+    private selectItem;
+    /**
+     * Deselects an item
+     */
+    private deselectItem;
+    /**
+     * Make sure that it could be locked
+     */
+    private canItBeLocked;
+    private emitChange;
     static ɵfac: i0.ɵɵFactoryDeclaration<Selection<any>, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<Selection<any>>;
 }

package/data/datagrid/providers/sort.d.ts

@@ -4,24 +4,23 @@ import { StateDebouncer } from './state-debouncer.provider';
 import * as i0 from "@angular/core";
 export declare class Sort<T = any> {
     private stateDebouncer;
-    constructor(stateDebouncer: StateDebouncer);
     /**
      * Currently active comparator
      */
     private _comparator;
-    get comparator(): ClrDatagridComparatorInterface<T>;
-    set comparator(value: ClrDatagridComparatorInterface<T>);
     /**
      * Ascending order if false, descending if true
      */
     private _reverse;
-    get reverse(): boolean;
-    set reverse(value: boolean);
     /**
      * The Observable that lets other classes subscribe to sort changes
      */
     private _change;
-    private emitChange;
+    constructor(stateDebouncer: StateDebouncer);
+    get comparator(): ClrDatagridComparatorInterface<T>;
+    set comparator(value: ClrDatagridComparatorInterface<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
@@ -39,6 +38,7 @@ export declare class Sort<T = any> {
      * Compares two objects according to the current comparator
      */
     compare(a: T, b: T): number;
+    private emitChange;
     static ɵfac: i0.ɵɵFactoryDeclaration<Sort<any>, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<Sort<any>>;
 }

package/data/datagrid/providers/state-debouncer.provider.d.ts

@@ -1,12 +1,12 @@
 import { Observable } from 'rxjs';
 import * as i0 from "@angular/core";
 export declare class StateDebouncer {
+    private nbChanges;
     /**
      * The Observable that lets other classes subscribe to global state changes
      */
     private _change;
     get change(): Observable<void>;
-    private nbChanges;
     changeStart(): void;
     changeDone(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<StateDebouncer, never>;

package/data/datagrid/providers/state.provider.d.ts

@@ -13,11 +13,11 @@ export declare class StateProvider<T> {
     private sort;
     private page;
     private debouncer;
-    constructor(filters: FiltersProvider<T>, sort: Sort<T>, page: Page, debouncer: StateDebouncer);
     /**
      * The Observable that lets other classes subscribe to global state changes
      */
     change: Observable<ClrDatagridStateInterface<T>>;
+    constructor(filters: FiltersProvider<T>, sort: Sort<T>, page: Page, debouncer: StateDebouncer);
     get state(): ClrDatagridStateInterface<T>;
     static ɵfac: i0.ɵɵFactoryDeclaration<StateProvider<any>, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<StateProvider<any>>;

package/data/datagrid/providers/table-size.service.d.ts

@@ -7,9 +7,9 @@ import * as i0 from "@angular/core";
 export declare class TableSizeService {
     private platformId;
     private _tableRef;
+    constructor(platformId: any);
     get tableRef(): HTMLElement;
     set tableRef(element: HTMLElement);
-    constructor(platformId: any);
     set table(table: ElementRef);
     getColumnDragHeight(): string;
     static ɵfac: i0.ɵɵFactoryDeclaration<TableSizeService, never>;

package/data/datagrid/render/cell-renderer.d.ts

@@ -6,11 +6,11 @@ import * as i0 from "@angular/core";
 export declare class DatagridCellRenderer implements OnDestroy {
     private el;
     private renderer;
-    private stateSubscription;
     private runAllChanges;
-    set columnState(columnState: BehaviorSubject<ColumnState>);
-    constructor(el: ElementRef, renderer: Renderer2, organizer: DatagridRenderOrganizer);
+    private stateSubscription;
     private subscriptions;
+    constructor(el: ElementRef, renderer: Renderer2, organizer: DatagridRenderOrganizer);
+    set columnState(columnState: BehaviorSubject<ColumnState>);
     ngOnDestroy(): void;
     private stateChanges;
     private clearWidth;

package/data/datagrid/render/header-renderer.d.ts

@@ -14,7 +14,6 @@ export declare class DatagridHeaderRenderer implements OnDestroy {
     private columnResizerService;
     private columnsService;
     private columnState;
-    constructor(el: ElementRef, renderer: Renderer2, organizer: DatagridRenderOrganizer, domAdapter: DomAdapter, columnResizerService: ColumnResizerService, columnsService: ColumnsService, columnState: BehaviorSubject<ColumnState>);
     resizeEmitter: EventEmitter<number>;
     /**
      * Indicates if the column has a strict width, so it doesn't shrink or expand based on the content.
@@ -22,13 +21,14 @@ export declare class DatagridHeaderRenderer implements OnDestroy {
     private widthSet;
     private autoSet;
     private subscriptions;
+    constructor(el: ElementRef, renderer: Renderer2, organizer: DatagridRenderOrganizer, domAdapter: DomAdapter, columnResizerService: ColumnResizerService, columnsService: ColumnsService, columnState: BehaviorSubject<ColumnState>);
     ngOnDestroy(): void;
+    getColumnWidthState(): Partial<ColumnState>;
+    setColumnState(index: number): void;
     private stateChanges;
     private clearWidth;
     private detectStrictWidth;
     private computeWidth;
-    getColumnWidthState(): Partial<ColumnState>;
-    setColumnState(index: number): void;
     private setWidth;
     private setHidden;
     static ɵfac: i0.ɵɵFactoryDeclaration<DatagridHeaderRenderer, never>;

package/data/datagrid/render/main-renderer.d.ts

@@ -20,16 +20,25 @@ export declare class DatagridMainRenderer implements AfterContentInit, AfterView
     private tableSizeService;
     private columnsService;
     private ngZone;
-    constructor(organizer: DatagridRenderOrganizer, items: Items, page: Page, domAdapter: DomAdapter, el: ElementRef, renderer: Renderer2, detailService: DetailService, tableSizeService: TableSizeService, columnsService: ColumnsService, ngZone: NgZone);
     private headers;
     private rows;
+    private _heightSet;
+    private shouldStabilizeColumns;
+    private subscriptions;
+    /**
+     * Indicates if we want to re-compute columns width. This should only happen:
+     * 1) When headers change, with columns being added or removed
+     * 2) When rows are lazily loaded for the first time
+     */
+    private columnsSizesStable;
+    constructor(organizer: DatagridRenderOrganizer, items: Items, page: Page, domAdapter: DomAdapter, el: ElementRef, renderer: Renderer2, detailService: DetailService, tableSizeService: TableSizeService, columnsService: ColumnsService, ngZone: NgZone);
     ngAfterContentInit(): void;
     ngAfterViewInit(): void;
     ngAfterViewChecked(): void;
+    ngOnDestroy(): void;
+    toggleDetailPane(state: boolean): void;
     private setupColumns;
-    private _heightSet;
     private shouldComputeHeight;
-    toggleDetailPane(state: boolean): void;
     /**
      * Computes the height of the datagrid.
      *
@@ -42,19 +51,10 @@ export declare class DatagridMainRenderer implements AfterContentInit, AfterView
      */
     private computeDatagridHeight;
     private resetDatagridHeight;
-    private subscriptions;
-    ngOnDestroy(): void;
     /**
      * Makes each header compute its width.
      */
     private computeHeadersWidth;
-    /**
-     * Indicates if we want to re-compute columns width. This should only happen:
-     * 1) When headers change, with columns being added or removed
-     * 2) When rows are lazily loaded for the first time
-     */
-    private columnsSizesStable;
-    private shouldStabilizeColumns;
     /**
      * Triggers a whole re-rendring cycle to set column sizes, if needed.
      */

package/data/datagrid/render/noop-dom-adapter.d.ts

@@ -1,13 +1,13 @@
 import { DomAdapter } from '../../../utils/dom-adapter/dom-adapter';
 import * as i0 from "@angular/core";
 export declare class NoopDomAdapter implements DomAdapter {
-    userDefinedWidth(element: any): number;
-    scrollBarWidth(element: any): number;
-    scrollWidth(element: any): number;
-    computedHeight(element: any): number;
-    clientRect(element: any): DOMRect;
-    minWidth(element: any): number;
-    focus(element: any): void;
+    userDefinedWidth(_element: any): number;
+    scrollBarWidth(_element: any): number;
+    scrollWidth(_element: any): number;
+    computedHeight(_element: any): number;
+    clientRect(_element: any): DOMRect;
+    minWidth(_element: any): number;
+    focus(_element: any): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<NoopDomAdapter, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<NoopDomAdapter>;
 }

package/data/datagrid/render/render-organizer.d.ts

@@ -3,9 +3,9 @@ import { DatagridRenderStep } from '../enums/render-step.enum';
 import * as i0 from "@angular/core";
 export declare class DatagridRenderOrganizer {
     protected _renderStep: Subject<DatagridRenderStep>;
+    private alreadySized;
     get renderStep(): Observable<DatagridRenderStep>;
     filterRenderSteps(step: DatagridRenderStep): Observable<DatagridRenderStep>;
-    private alreadySized;
     resize(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<DatagridRenderOrganizer, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<DatagridRenderOrganizer>;

package/data/datagrid/render/row-renderer.d.ts

@@ -4,9 +4,9 @@ import * as i0 from "@angular/core";
 export declare class DatagridRowRenderer implements AfterContentInit, OnDestroy {
     private columnsService;
     private cells;
+    private subscriptions;
     constructor(columnsService: ColumnsService);
     ngAfterContentInit(): void;
-    private subscriptions;
     ngOnDestroy(): void;
     setColumnState(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<DatagridRowRenderer, never>;

package/data/datagrid/utils/datagrid-filter-registrar.d.ts

@@ -4,15 +4,15 @@ import { FiltersProvider, RegisteredFilter } from '../providers/filters';
 import * as i0 from "@angular/core";
 export declare abstract class DatagridFilterRegistrar<T, F extends ClrDatagridFilterInterface<T>> implements OnDestroy {
     private filters;
-    constructor(filters: FiltersProvider<T>);
     /**
      * @NOTEe Type `any` is set here to be able to pass templateStrictMode
      */
     registered: any;
+    constructor(filters: FiltersProvider<T>);
     get filter(): F;
+    ngOnDestroy(): void;
     setFilter(filter: F | RegisteredFilter<T, F>): void;
     deleteFilter(): void;
-    ngOnDestroy(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<DatagridFilterRegistrar<any, any>, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<DatagridFilterRegistrar<any, any>, never, never, {}, {}, never, never, false, never>;
 }

package/data/datagrid/utils/key-navigation-grid.controller.d.ts

@@ -8,15 +8,15 @@ export interface KeyNavigationGridConfig {
 }
 export declare class KeyNavigationGridController implements OnDestroy {
     private zone;
-    private get grid();
-    private get rows();
-    private get cells();
+    private host;
     private config;
     private listenersAdded;
-    private host;
     private destroy$;
-    ngOnDestroy(): void;
     constructor(zone: NgZone);
+    private get grid();
+    private get rows();
+    private get cells();
+    ngOnDestroy(): void;
     addListeners(): void;
     initializeKeyGrid(host: HTMLElement): void;
     resetKeyGrid(): void;

package/data/stack-view/stack-block.d.ts

@@ -5,32 +5,32 @@ export declare class ClrStackBlock implements OnInit {
     private parent;
     commonStrings: ClrCommonStringsService;
     expanded: boolean;
-    expandedChange: EventEmitter<boolean>;
     expandable: boolean;
+    /**
+     * Depth of the stack view starting from 1 for first level
+     */
+    ariaLevel: number;
+    expandedChange: EventEmitter<boolean>;
     stackBlockTitle: any;
     focused: boolean;
+    uniqueId: string;
     private _changedChildren;
     private _fullyInitialized;
     private _changed;
-    get getChangedValue(): boolean;
+    constructor(parent: ClrStackBlock, commonStrings: ClrCommonStringsService);
     set setChangedValue(value: boolean);
+    get getChangedValue(): boolean;
+    get onStackLabelFocus(): boolean;
     get labelledById(): any;
     get headingLevel(): string;
-    uniqueId: string;
-    /**
-     * Depth of the stack view starting from 1 for first level
-     */
-    ariaLevel: number;
-    constructor(parent: ClrStackBlock, commonStrings: ClrCommonStringsService);
-    ngOnInit(): void;
-    addChild(): void;
-    toggleExpand(): void;
     get caretDirection(): string;
     get role(): string;
     get tabIndex(): string;
-    get onStackLabelFocus(): boolean;
     get ariaExpanded(): string;
+    ngOnInit(): void;
+    addChild(): void;
+    toggleExpand(): void;
     getStackChildrenId(): string;
     static ɵfac: i0.ɵɵFactoryDeclaration<ClrStackBlock, [{ optional: true; skipSelf: true; }, null]>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<ClrStackBlock, "clr-stack-block", never, { "expanded": "clrSbExpanded"; "expandable": "clrSbExpandable"; "setChangedValue": "clrSbNotifyChange"; "ariaLevel": "clrStackViewLevel"; }, { "expandedChange": "clrSbExpandedChange"; }, ["stackBlockTitle"], ["clr-stack-label", "*", "clr-stack-block"], false, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ClrStackBlock, "clr-stack-block", never, { "expanded": "clrSbExpanded"; "expandable": "clrSbExpandable"; "ariaLevel": "clrStackViewLevel"; "setChangedValue": "clrSbNotifyChange"; }, { "expandedChange": "clrSbExpandedChange"; }, ["stackBlockTitle"], ["clr-stack-label", "*", "clr-stack-block"], false, never>;
 }

package/data/stack-view/stack-view-custom-tags.d.ts

@@ -7,8 +7,8 @@ export declare class ClrStackViewCustomTags {
 export declare class ClrStackViewLabel implements OnInit {
     private _generatedId;
     private _id;
-    set id(val: string);
     get id(): string;
+    set id(val: string);
     ngOnInit(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<ClrStackViewLabel, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<ClrStackViewLabel, "clr-stack-label", never, { "id": "id"; }, {}, never, ["*"], false, never>;

package/data/tree-view/models/declarative-tree-node.model.d.ts

@@ -1,9 +1,9 @@
 import { TreeNodeModel } from './tree-node.model';
 export declare class DeclarativeTreeNodeModel<T> extends TreeNodeModel<T> {
-    constructor(parent: DeclarativeTreeNodeModel<T> | null);
     parent: DeclarativeTreeNodeModel<T> | null;
     children: DeclarativeTreeNodeModel<T>[];
+    constructor(parent: DeclarativeTreeNodeModel<T> | null);
+    destroy(): void;
     _addChild(child: DeclarativeTreeNodeModel<T>): void;
     _removeChild(child: DeclarativeTreeNodeModel<T>): void;
-    destroy(): void;
 }

package/data/tree-view/models/recursive-tree-node.model.d.ts

@@ -4,15 +4,15 @@ import { TreeNodeModel } from './tree-node.model';
 export declare class RecursiveTreeNodeModel<T> extends TreeNodeModel<T> {
     private getChildren;
     private featuresService;
-    constructor(model: T, parent: RecursiveTreeNodeModel<T> | null, getChildren: (node: T) => AsyncArray<T> | undefined, featuresService: TreeFeaturesService<T> | undefined);
     parent: RecursiveTreeNodeModel<T> | null;
+    private subscription;
     private childrenFetched;
-    clearChildren(): void;
-    fetchChildren(): void;
-    private wrapChildren;
     private _children;
+    constructor(model: T, parent: RecursiveTreeNodeModel<T> | null, getChildren: (node: T) => AsyncArray<T> | undefined, featuresService: TreeFeaturesService<T> | undefined);
     get children(): RecursiveTreeNodeModel<T>[];
     set children(value: RecursiveTreeNodeModel<T>[]);
-    private subscription;
     destroy(): void;
+    clearChildren(): void;
+    fetchChildren(): void;
+    private wrapChildren;
 }

package/data/tree-view/models/tree-node.model.d.ts

@@ -3,18 +3,18 @@ import { ClrSelectedState } from './selected-state.enum';
 export declare abstract class TreeNodeModel<T> {
     nodeId: string;
     expanded: boolean;
-    selected: BehaviorSubject<ClrSelectedState>;
     model: T | null;
     textContent: string;
+    loading$: BehaviorSubject<boolean>;
+    selected: BehaviorSubject<ClrSelectedState>;
+    private _loading;
     abstract parent: TreeNodeModel<T> | null;
     abstract children: TreeNodeModel<T>[];
-    private _loading;
-    loading$: BehaviorSubject<boolean>;
     get loading(): boolean;
     set loading(isLoading: boolean);
     destroy(): void;
     setSelected(state: ClrSelectedState, propagateUp: boolean, propagateDown: boolean): void;
     toggleSelection(propagate: boolean): void;
-    private computeSelectionStateFromChildren;
     _updateSelectionFromChildren(): void;
+    private computeSelectionStateFromChildren;
 }

package/data/tree-view/recursive-children.d.ts

@@ -7,12 +7,12 @@ import * as i0 from "@angular/core";
 export declare class RecursiveChildren<T> {
     featuresService: TreeFeaturesService<T>;
     private expandService;
-    constructor(featuresService: TreeFeaturesService<T>, expandService: IfExpandService);
-    shouldRender(): boolean;
     parent: TreeNodeModel<T>;
     children: TreeNodeModel<T>[];
-    getContext(node: TreeNodeModel<T>): ClrRecursiveForOfContext<T>;
     subscription: Subscription;
+    constructor(featuresService: TreeFeaturesService<T>, expandService: IfExpandService);
+    shouldRender(): boolean;
+    getContext(node: TreeNodeModel<T>): ClrRecursiveForOfContext<T>;
     ngOnDestroy(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<RecursiveChildren<any>, [null, { optional: true; }]>;
     static ɵcmp: i0.ɵɵComponentDeclaration<RecursiveChildren<any>, "clr-recursive-children", never, { "parent": "parent"; "children": "children"; }, {}, never, never, false, never>;

package/data/tree-view/recursive-for-of.d.ts

@@ -11,10 +11,10 @@ export declare class ClrRecursiveForOf<T> implements OnChanges, OnDestroy {
     private template;
     private featuresService;
     private cdr;
-    constructor(template: TemplateRef<ClrRecursiveForOfContext<T>>, featuresService: TreeFeaturesService<T>, cdr: ChangeDetectorRef);
     nodes: T | T[];
     getChildren: (node: T) => AsyncArray<T>;
     private childrenFetchSubscription;
+    constructor(template: TemplateRef<ClrRecursiveForOfContext<T>>, featuresService: TreeFeaturesService<T>, cdr: ChangeDetectorRef);
     ngOnChanges(): void;
     ngOnDestroy(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<ClrRecursiveForOf<any>, never>;

package/data/tree-view/tree-focus-manager.service.d.ts

@@ -8,6 +8,14 @@ export declare class TreeFocusManagerService<T> {
     private _focusChange;
     get focusRequest(): Observable<string>;
     get focusChange(): Observable<string>;
+    focusNode(model: TreeNodeModel<T>): void;
+    broadcastFocusedNode(nodeId: string): void;
+    focusParent(model: TreeNodeModel<T>): void;
+    focusFirstVisibleNode(): void;
+    focusLastVisibleNode(): void;
+    focusNodeAbove(model: TreeNodeModel<T>): void;
+    focusNodeBelow(model: TreeNodeModel<T>): void;
+    focusNodeStartsWith(searchString: string, model: TreeNodeModel<T>): void;
     private findSiblings;
     private findLastVisibleInNode;
     private findNextFocusable;
@@ -19,14 +27,6 @@ export declare class TreeFocusManagerService<T> {
     private findRootNodeStartsWith;
     private findNodeStartsWith;
     private findClosestNodeStartsWith;
-    focusNode(model: TreeNodeModel<T>): void;
-    broadcastFocusedNode(nodeId: string): void;
-    focusParent(model: TreeNodeModel<T>): void;
-    focusFirstVisibleNode(): void;
-    focusLastVisibleNode(): void;
-    focusNodeAbove(model: TreeNodeModel<T>): void;
-    focusNodeBelow(model: TreeNodeModel<T>): void;
-    focusNodeStartsWith(searchString: string, model: TreeNodeModel<T>): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<TreeFocusManagerService<any>, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<TreeFocusManagerService<any>>;
 }

package/data/tree-view/tree-node.d.ts

@@ -14,44 +14,44 @@ export declare class ClrTreeNode<T> implements OnInit, AfterContentInit, AfterVi
     commonStrings: ClrCommonStringsService;
     private focusManager;
     private elementRef;
+    expandable: boolean | undefined;
+    selectedChange: EventEmitter<ClrSelectedState>;
+    expandedChange: EventEmitter<boolean>;
     STATES: typeof ClrSelectedState;
-    private skipEmitChange;
     isModelLoading: boolean;
     nodeId: string;
-    private typeAheadKeyEvent;
+    contentContainerTabindex: number;
+    _model: TreeNodeModel<T>;
+    private skipEmitChange;
     private typeAheadKeyBuffer;
+    private typeAheadKeyEvent;
+    private subscriptions;
+    private contentContainer;
+    private treeNodeLinkList;
     constructor(platformId: any, parent: ClrTreeNode<T>, featuresService: TreeFeaturesService<T>, expandService: IfExpandService, commonStrings: ClrCommonStringsService, focusManager: TreeFocusManagerService<T>, elementRef: ElementRef<HTMLElement>, injector: Injector);
-    _model: TreeNodeModel<T>;
-    isExpandable(): boolean;
-    isSelectable(): boolean;
     get selected(): ClrSelectedState | boolean;
     set selected(value: ClrSelectedState | boolean);
-    selectedChange: EventEmitter<ClrSelectedState>;
-    get ariaSelected(): boolean;
-    expandable: boolean | undefined;
     get expanded(): boolean;
     set expanded(value: boolean);
     set clrForTypeAhead(value: string);
-    expandedChange: EventEmitter<boolean>;
-    private subscriptions;
-    contentContainerTabindex: number;
-    private contentContainer;
+    get ariaSelected(): boolean;
+    get treeNodeLink(): ClrTreeNodeLink;
+    private get isParent();
     ngOnInit(): void;
     ngAfterContentInit(): void;
     ngAfterViewInit(): void;
     ngOnDestroy(): void;
-    private treeNodeLinkList;
-    get treeNodeLink(): ClrTreeNodeLink;
-    private setTabIndex;
-    private checkTabIndex;
+    isExpandable(): boolean;
+    isSelectable(): boolean;
     focusTreeNode(): void;
     broadcastFocusOnContainer(): void;
     onKeyDown(event: KeyboardEvent): void;
-    private get isParent();
+    private setTabIndex;
+    private checkTabIndex;
     private toggleExpandOrTriggerDefault;
     private expandOrFocusFirstChild;
     private collapseOrFocusParent;
     private triggerDefaultAction;
     static ɵfac: i0.ɵɵFactoryDeclaration<ClrTreeNode<any>, [null, { optional: true; skipSelf: true; }, null, null, null, null, null, null]>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<ClrTreeNode<any>, "clr-tree-node", never, { "selected": "clrSelected"; "expandable": "clrExpandable"; "expanded": "clrExpanded"; "clrForTypeAhead": "clrForTypeAhead"; }, { "selectedChange": "clrSelectedChange"; "expandedChange": "clrExpandedChange"; }, ["treeNodeLinkList"], ["*", "clr-tree-node", "[clrIfExpanded]"], false, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ClrTreeNode<any>, "clr-tree-node", never, { "expandable": "clrExpandable"; "selected": "clrSelected"; "expanded": "clrExpanded"; "clrForTypeAhead": "clrForTypeAhead"; }, { "selectedChange": "clrSelectedChange"; "expandedChange": "clrExpandedChange"; }, ["treeNodeLinkList"], ["*", "clr-tree-node", "[clrIfExpanded]"], false, never>;
 }

package/data/tree-view/tree.d.ts

@@ -5,14 +5,14 @@ import * as i0 from "@angular/core";
 export declare class ClrTree<T> implements AfterContentInit, OnDestroy {
     featuresService: TreeFeaturesService<T>;
     private focusManagerService;
+    private rootNodes;
     private subscriptions;
     constructor(featuresService: TreeFeaturesService<T>, focusManagerService: TreeFocusManagerService<T>, { nativeElement }: ElementRef<HTMLElement>, renderer: Renderer2, ngZone: NgZone);
     set lazy(value: boolean);
     get isMultiSelectable(): boolean;
-    private rootNodes;
     ngAfterContentInit(): void;
-    private setRootNodes;
     ngOnDestroy(): void;
+    private setRootNodes;
     static ɵfac: i0.ɵɵFactoryDeclaration<ClrTree<any>, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<ClrTree<any>, "clr-tree", never, { "lazy": "clrLazy"; }, {}, ["rootNodes"], ["*"], false, never>;
 }