@koobiq/components 16.0.0-beta.1

package/tree/tree-selection.component.d.ts

@@ -0,0 +1,134 @@
+import { Clipboard } from '@angular/cdk/clipboard';
+import { SelectionModel } from '@angular/cdk/collections';
+import { AfterContentInit, ChangeDetectorRef, ElementRef, EventEmitter, IterableDiffer, IterableDiffers, QueryList, ViewContainerRef } from '@angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+import { FocusKeyManager } from '@koobiq/cdk/a11y';
+import { CanDisable, HasTabIndex, MultipleMode } from '@koobiq/components/core';
+import { Observable } from 'rxjs';
+import { AsyncScheduler } from 'rxjs/internal/scheduler/AsyncScheduler';
+import { FlatTreeControl } from './control/flat-tree-control';
+import { KbqTreeNodeOutlet } from './outlet';
+import { KbqTreeBase } from './tree-base';
+import { KbqTreeOption, KbqTreeOptionEvent } from './tree-option.component';
+import * as i0 from "@angular/core";
+export declare const KBQ_SELECTION_TREE_VALUE_ACCESSOR: any;
+export declare class KbqTreeSelectAllEvent<T> {
+    source: KbqTreeSelection;
+    options: T[];
+    constructor(source: KbqTreeSelection, options: T[]);
+}
+export declare class KbqTreeCopyEvent<T> {
+    source: KbqTreeSelection;
+    option: T;
+    constructor(source: KbqTreeSelection, option: T);
+}
+export declare class KbqTreeNavigationChange<T> {
+    source: KbqTreeSelection;
+    option: T;
+    constructor(source: KbqTreeSelection, option: T);
+}
+export declare class KbqTreeSelectionChange<T> {
+    source: KbqTreeSelection;
+    option: T;
+    constructor(source: KbqTreeSelection, option: T);
+}
+interface SelectionModelOption {
+    id: number | string;
+    value: string;
+}
+export declare class KbqTreeSelection extends KbqTreeBase<any> implements ControlValueAccessor, AfterContentInit, CanDisable, HasTabIndex {
+    private elementRef;
+    private scheduler;
+    private clipboard;
+    renderedOptions: QueryList<KbqTreeOption>;
+    keyManager: FocusKeyManager<KbqTreeOption>;
+    selectionModel: SelectionModel<SelectionModelOption>;
+    resetFocusedItemOnBlur: boolean;
+    multipleMode: MultipleMode | null;
+    userTabIndex: number | null;
+    optionShouldHoldFocusOnBlur: boolean;
+    nodeOutlet: KbqTreeNodeOutlet;
+    unorderedOptions: QueryList<KbqTreeOption>;
+    treeControl: FlatTreeControl<any>;
+    readonly navigationChange: EventEmitter<KbqTreeNavigationChange<KbqTreeOption>>;
+    readonly selectionChange: EventEmitter<KbqTreeSelectionChange<KbqTreeOption>>;
+    readonly onSelectAll: EventEmitter<KbqTreeSelectAllEvent<KbqTreeOption>>;
+    readonly onCopy: EventEmitter<KbqTreeCopyEvent<KbqTreeOption>>;
+    private sortedNodes;
+    get autoSelect(): boolean;
+    set autoSelect(value: boolean);
+    private _autoSelect;
+    get optionFocusChanges(): Observable<KbqTreeOptionEvent>;
+    get optionBlurChanges(): Observable<KbqTreeOptionEvent>;
+    get multiple(): boolean;
+    get noUnselectLast(): boolean;
+    set noUnselectLast(value: boolean);
+    private _noUnselectLast;
+    get disabled(): boolean;
+    set disabled(rawValue: boolean);
+    private _disabled;
+    get tabIndex(): any;
+    set tabIndex(value: any);
+    private _tabIndex;
+    get showCheckbox(): boolean;
+    get isEmpty(): boolean;
+    private readonly destroy;
+    private optionFocusSubscription;
+    private optionBlurSubscription;
+    constructor(elementRef: ElementRef, scheduler: AsyncScheduler, differs: IterableDiffers, changeDetectorRef: ChangeDetectorRef, multiple: MultipleMode, clipboard: Clipboard);
+    ngAfterContentInit(): void;
+    ngOnDestroy(): void;
+    focus($event: any): void;
+    blur(): void;
+    onKeyDown(event: KeyboardEvent): void;
+    updateScrollSize(): void;
+    setSelectedOptionsByKey(option: KbqTreeOption, shiftKey: boolean, ctrlKey: boolean): void;
+    setSelectedOptionsByClick(option: KbqTreeOption, shiftKey: boolean, ctrlKey: boolean): void;
+    selectActiveOptions(): void;
+    setFocusedOption(option: KbqTreeOption): void;
+    toggleFocusedOption(): void;
+    renderNodeChanges(data: KbqTreeOption[], dataDiffer?: IterableDiffer<KbqTreeOption>, viewContainer?: ViewContainerRef, parentData?: KbqTreeOption): void;
+    emitNavigationEvent(option: KbqTreeOption): void;
+    emitChangeEvent(option: KbqTreeOption): void;
+    selectAllOptions(): void;
+    copyActiveOption(): void;
+    writeValue(value: any): void;
+    /** `View -> model callback called when value changes` */
+    onChange: (value: any) => void;
+    registerOnChange(fn: (value: any) => void): void;
+    /** `View -> model callback called when select has been touched` */
+    onTouched: () => void;
+    registerOnTouched(fn: () => {}): void;
+    /**
+     * Sets the disabled state of the control. Implemented as a part of ControlValueAccessor.
+     */
+    setDisabledState(isDisabled: boolean): void;
+    setOptionsFromValues(values: any[]): void;
+    getSelectedValues(): any[];
+    getItemHeight(): number;
+    setStateChildren(option: KbqTreeOption, state: boolean): void;
+    private onCopyDefaultHandler;
+    private getHeight;
+    private updateTabIndex;
+    private updateRenderedOptions;
+    private getSortedNodes;
+    private allowFocusEscape;
+    private resetOptions;
+    private dropSubscriptions;
+    private listenToOptionsFocus;
+    /**
+     * Utility to ensure all indexes are valid.
+     * @param index The index to be checked.
+     * @returns True if the index is valid for our list of options.
+     */
+    private isValidIndex;
+    /** Checks whether any of the options is focused. */
+    private hasFocusedOption;
+    private markOptionsForCheck;
+    private updateOptionsFocus;
+    private canDeselectLast;
+    private isFocusReceivedFromNestedOption;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KbqTreeSelection, [null, null, null, null, { attribute: "multiple"; }, { optional: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KbqTreeSelection, "kbq-tree-selection", ["mcTreeSelection"], { "treeControl": { "alias": "treeControl"; "required": false; }; "autoSelect": { "alias": "autoSelect"; "required": false; }; "noUnselectLast": { "alias": "noUnselectLast"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "tabIndex": { "alias": "tabIndex"; "required": false; }; }, { "navigationChange": "navigationChange"; "selectionChange": "selectionChange"; "onSelectAll": "onSelectAll"; "onCopy": "onCopy"; }, ["unorderedOptions"], never, false, never>;
+}
+export {};

package/tree/tree-selection.scss

@@ -0,0 +1,3 @@
+.kbq-tree-selection {
+    display: block;
+}

package/tree/tree.d.ts

@@ -0,0 +1,6 @@
+import { KbqTreeBase } from './tree-base';
+import * as i0 from "@angular/core";
+export declare class KbqTree extends KbqTreeBase<any> {
+    static ɵfac: i0.ɵɵFactoryDeclaration<KbqTree, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KbqTree, "kbq-tree", ["mcTree"], {}, {}, never, never, false, never>;
+}

package/tree/tree.module.d.ts

@@ -0,0 +1,16 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./outlet";
+import * as i2 from "./node";
+import * as i3 from "./tree-base";
+import * as i4 from "./padding.directive";
+import * as i5 from "./tree";
+import * as i6 from "./tree-selection.component";
+import * as i7 from "./tree-option.component";
+import * as i8 from "./toggle";
+import * as i9 from "@angular/common";
+import * as i10 from "@koobiq/components/core";
+export declare class KbqTreeModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<KbqTreeModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<KbqTreeModule, [typeof i1.KbqTreeNodeOutlet, typeof i2.KbqTreeNodeDef, typeof i3.KbqTreeNode, typeof i4.KbqTreeNodePadding, typeof i5.KbqTree, typeof i6.KbqTreeSelection, typeof i7.KbqTreeOption, typeof i8.KbqTreeNodeToggleComponent, typeof i8.KbqTreeNodeToggleDirective], [typeof i9.CommonModule, typeof i10.KbqPseudoCheckboxModule], [typeof i1.KbqTreeNodeOutlet, typeof i2.KbqTreeNodeDef, typeof i3.KbqTreeNode, typeof i4.KbqTreeNodePadding, typeof i5.KbqTree, typeof i6.KbqTreeSelection, typeof i7.KbqTreeOption, typeof i8.KbqTreeNodeToggleComponent, typeof i8.KbqTreeNodeToggleDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<KbqTreeModule>;
+}

package/tree/tree.scss

@@ -0,0 +1,3 @@
+.kbq-tree {
+    display: block;
+}

package/tree-select/_tree-select-theme.scss

@@ -0,0 +1,41 @@
+@use 'sass:meta';
+@use 'sass:map';
+
+@use '../core/styles/theming/theming' as *;
+@use '../core/styles/typography/typography-utils' as *;
+@use '../core/styles/common/popup' as *;
+
+
+@mixin kbq-tree-select-theme($theme) {
+    $foreground: map.get($theme, foreground);
+    $error: map.get($theme, error);
+
+    .kbq-tree-select {
+        color: map.get($foreground, text);
+
+        &.ng-invalid {
+            color: kbq-color($error);
+        }
+
+        &.kbq-disabled {
+            color: map.get($foreground, text-disabled);
+        }
+    }
+
+    .kbq-tree-select__placeholder {
+        color: map.get($foreground, text-disabled);
+    }
+
+    .kbq-tree-select__panel {
+        @include popup-params($theme);
+    }
+}
+
+@mixin kbq-tree-select-typography($config) {
+    $tokens: map.get($config, tokens);
+
+    .kbq-tree-select,
+    .kbq-tree-select__panel {
+        @include kbq-typography-level-to-styles($config, map.get($tokens, select-panel-font-default));
+    }
+}

package/tree-select/index.d.ts

@@ -0,0 +1 @@
+export * from './public-api';

package/tree-select/public-api.d.ts

@@ -0,0 +1,2 @@
+export * from './tree-select.module';
+export * from './tree-select.component';

package/tree-select/tree-select.component.d.ts

@@ -0,0 +1,283 @@
+import { Directionality } from '@angular/cdk/bidi';
+import { SelectionModel } from '@angular/cdk/collections';
+import { CdkConnectedOverlay, ConnectedPosition, ViewportRuler } from '@angular/cdk/overlay';
+import { AfterContentInit, AfterViewInit, ChangeDetectorRef, DoCheck, ElementRef, EventEmitter, NgZone, OnChanges, OnDestroy, OnInit, QueryList, Renderer2, SimpleChanges } from '@angular/core';
+import { ControlValueAccessor, FormGroupDirective, NgControl, NgForm } from '@angular/forms';
+import { CanDisable, CanUpdateErrorState, ErrorStateMatcher, HasTabIndex, CanDisableCtor, HasTabIndexCtor, CanUpdateErrorStateCtor } from '@koobiq/components/core';
+import { KbqCleaner, KbqFormField, KbqFormFieldControl } from '@koobiq/components/form-field';
+import { KbqSelectSearch } from '@koobiq/components/select';
+import { KbqTag } from '@koobiq/components/tags';
+import { KbqTreeSelection, KbqTreeOption } from '@koobiq/components/tree';
+import { Observable, Subject } from 'rxjs';
+import * as i0 from "@angular/core";
+export interface ITriggerValue {
+    disabled: boolean;
+    value: string;
+    viewValue: string;
+}
+/** Change event object that is emitted when the select value has changed. */
+export declare class KbqTreeSelectChange {
+    source: KbqTreeSelect;
+    value: any;
+    isUserInput: boolean;
+    constructor(source: KbqTreeSelect, value: any, isUserInput?: boolean);
+}
+export declare class KbqTreeSelectTrigger {
+    static ɵfac: i0.ɵɵFactoryDeclaration<KbqTreeSelectTrigger, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<KbqTreeSelectTrigger, "kbq-tree-select-trigger", never, {}, {}, never, never, false, never>;
+}
+export declare class KbqTreeSelectFooter {
+    static ɵfac: i0.ɵɵFactoryDeclaration<KbqTreeSelectFooter, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<KbqTreeSelectFooter, "kbq-tree-select-footer, [kbq-tree-select-footer], [kbq-tree-selection-footer]", never, {}, {}, never, never, false, never>;
+}
+/** @docs-private */
+declare class KbqTreeSelectBase {
+    elementRef: ElementRef;
+    defaultErrorStateMatcher: ErrorStateMatcher;
+    parentForm: NgForm;
+    parentFormGroup: FormGroupDirective;
+    ngControl: NgControl;
+    /**
+     * Emits whenever the component state changes and should cause the parent
+     * form-field to update. Implemented as part of `KbqFormFieldControl`.
+     * @docs-private
+     */
+    readonly stateChanges: Subject<void>;
+    constructor(elementRef: ElementRef, defaultErrorStateMatcher: ErrorStateMatcher, parentForm: NgForm, parentFormGroup: FormGroupDirective, ngControl: NgControl);
+}
+/** @docs-private */
+declare const KbqTreeSelectMixinBase: CanDisableCtor & HasTabIndexCtor & CanUpdateErrorStateCtor & typeof KbqTreeSelectBase;
+export declare class KbqTreeSelect extends KbqTreeSelectMixinBase implements AfterContentInit, AfterViewInit, OnChanges, OnDestroy, OnInit, DoCheck, ControlValueAccessor, CanDisable, HasTabIndex, KbqFormFieldControl<KbqTreeOption>, CanUpdateErrorState {
+    readonly changeDetectorRef: ChangeDetectorRef;
+    private readonly viewportRuler;
+    private readonly ngZone;
+    private readonly renderer;
+    private readonly scrollStrategyFactory;
+    private readonly dir;
+    private readonly parentFormField;
+    /** A name for this control that can be used by `kbq-form-field`. */
+    controlType: string;
+    hiddenItems: number;
+    /** The last measured value for the trigger's client bounding rect. */
+    triggerRect: DOMRect;
+    /** The cached font-size of the trigger element. */
+    triggerFontSize: number;
+    /** Deals with the selection logic. */
+    selectionModel: SelectionModel<any>;
+    /** The value of the select panel's transform-origin property. */
+    transformOrigin: string;
+    /** Emits when the panel element is finished transforming in. */
+    panelDoneAnimatingStream: Subject<string>;
+    /** Strategy that will be used to handle scrolling while the select panel is open. */
+    scrollStrategy: any;
+    /**
+     * The y-offset of the overlay panel in relation to the trigger's top start corner.
+     * This must be adjusted to align the selected option text over the trigger text.
+     * when the panel opens. Will change based on the y-position of the selected option.
+     */
+    offsetY: number;
+    /**
+     * This position config ensures that the top "start" corner of the overlay
+     * is aligned with with the top "start" of the origin by default (overlapping
+     * the trigger completely). If the panel cannot fit below the trigger, it
+     * will fall back to a position above the trigger.
+     */
+    positions: ConnectedPosition[];
+    options: QueryList<KbqTreeOption>;
+    trigger: ElementRef;
+    panel: ElementRef;
+    overlayDir: CdkConnectedOverlay;
+    tags: QueryList<KbqTag>;
+    cleaner: KbqCleaner;
+    /** User-supplied override of the trigger element. */
+    customTrigger: KbqTreeSelectTrigger;
+    tree: KbqTreeSelection;
+    search: KbqSelectSearch;
+    hiddenItemsText: string;
+    /** Event emitted when the select panel has been toggled. */
+    readonly openedChange: EventEmitter<boolean>;
+    /** Event emitted when the select has been opened. */
+    readonly openedStream: Observable<void>;
+    /** Event emitted when the select has been closed. */
+    readonly closedStream: Observable<void>;
+    /** Event emitted when the selected value has been changed by the user. */
+    readonly selectionChange: EventEmitter<KbqTreeSelectChange>;
+    /**
+     * Event that emits whenever the raw value of the select changes. This is here primarily
+     * to facilitate the two-way binding for the `value` input.
+     * @docs-private
+     */
+    readonly valueChange: EventEmitter<any>;
+    /** Classes to be passed to the select panel. Supports the same syntax as `ngClass`. */
+    panelClass: string | string[] | Set<string> | {
+        [key: string]: any;
+    };
+    backdropClass: string;
+    /** Object used to control when error messages are shown. */
+    errorStateMatcher: ErrorStateMatcher;
+    /**
+     * Function used to sort the values in a select in multiple mode.
+     * Follows the same logic as `Array.prototype.sort`.
+     */
+    sortComparator: (a: KbqTreeOption, b: KbqTreeOption, options: KbqTreeOption[]) => number;
+    /** Combined stream of all of the child options' change events. */
+    readonly optionSelectionChanges: Observable<KbqTreeSelectChange>;
+    get placeholder(): string;
+    set placeholder(value: string);
+    private _placeholder;
+    get required(): boolean;
+    set required(value: boolean);
+    private _required;
+    get multiple(): boolean;
+    set multiple(value: boolean);
+    private _multiple;
+    get autoSelect(): boolean;
+    set autoSelect(value: boolean);
+    private _autoSelect;
+    /**
+     * Function to compare the option values with the selected values. The first argument
+     * is a value from an option. The second is a value from the selection. A boolean
+     * should be returned.
+     */
+    get compareWith(): (o1: any, o2: any) => boolean;
+    set compareWith(fn: (o1: any, o2: any) => boolean);
+    get value(): any;
+    private _value;
+    get id(): string;
+    set id(value: string);
+    private _id;
+    get hasBackdrop(): boolean;
+    set hasBackdrop(value: boolean);
+    private _hasBackdrop;
+    get disabled(): any;
+    set disabled(value: any);
+    private _disabled;
+    /** Whether the select is focused. */
+    get focused(): boolean;
+    set focused(value: boolean);
+    private _focused;
+    get panelOpen(): boolean;
+    get canShowCleaner(): boolean;
+    isEmptySearchResult: boolean;
+    triggerValues: ITriggerValue[];
+    private closeSubscription;
+    private _panelOpen;
+    private originalOnKeyDown;
+    /** The scroll position of the overlay panel, calculated to center the selected option. */
+    private scrollTop;
+    /** Unique id for this input. */
+    private readonly uid;
+    /** Emits whenever the component is destroyed. */
+    private readonly destroy;
+    private tempValues;
+    constructor(elementRef: ElementRef, changeDetectorRef: ChangeDetectorRef, viewportRuler: ViewportRuler, ngZone: NgZone, renderer: Renderer2, defaultErrorStateMatcher: ErrorStateMatcher, scrollStrategyFactory: any, dir: Directionality, parentForm: NgForm, parentFormGroup: FormGroupDirective, parentFormField: KbqFormField, ngControl: NgControl);
+    ngOnInit(): void;
+    ngAfterContentInit(): void;
+    ngAfterViewInit(): void;
+    ngDoCheck(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnDestroy(): void;
+    hiddenItemsTextFormatter(hiddenItemsText: string, hiddenItems: number): string;
+    clearValue($event: any): void;
+    /** `View -> model callback called when value changes` */
+    onChange: (value: any) => void;
+    /** `View -> model callback called when select has been touched` */
+    onTouched: () => void;
+    toggle(): void;
+    open(): void;
+    /** Closes the overlay panel and focuses the host element. */
+    close(): void;
+    /**
+     * Sets the select's value. Part of the ControlValueAccessor interface
+     * required to integrate with Angular's core forms API.
+     *
+     * @param value New value to be written to the model.
+     */
+    writeValue(value: any): void;
+    /**
+     * Saves a callback function to be invoked when the select's value
+     * changes from user input. Part of the ControlValueAccessor interface
+     * required to integrate with Angular's core forms API.
+     *
+     * @param fn Callback to be triggered when the value changes.
+     */
+    registerOnChange(fn: (value: any) => void): void;
+    /**
+     * Saves a callback function to be invoked when the select is blurred
+     * by the user. Part of the ControlValueAccessor interface required
+     * to integrate with Angular's core forms API.
+     *
+     * @param fn Callback to be triggered when the component has been touched.
+     */
+    registerOnTouched(fn: () => {}): void;
+    /**
+     * Disables the select. Part of the ControlValueAccessor interface required
+     * to integrate with Angular's core forms API.
+     *
+     * @param isDisabled Sets whether the component is disabled.
+     */
+    setDisabledState(isDisabled: boolean): void;
+    get selected(): any;
+    get selectedValues(): any;
+    get triggerValue(): string;
+    get empty(): boolean;
+    isRtl(): boolean;
+    handleKeydown(event: KeyboardEvent): void;
+    onFocus(): void;
+    /**
+     * Calls the touched callback only if the panel is closed. Otherwise, the trigger will
+     * "blur" to the panel when it opens, causing a false positive.
+     */
+    onBlur(): void;
+    /** Callback that is invoked when the overlay panel has been attached. */
+    onAttached(): void;
+    /** Returns the theme to be used on the panel. */
+    getPanelTheme(): string;
+    focus(): void;
+    /**
+     * Implemented as part of KbqFormFieldControl.
+     * @docs-private
+     */
+    onContainerClick(): void;
+    /** Invoked when an option is clicked. */
+    onRemoveSelectedOption(selectedOption: any, $event: any): void;
+    calculateHiddenItems(): void;
+    private closingActions;
+    private getTotalItemsWidthInMatcher;
+    private getTotalVisibleItems;
+    private buildTriggerClone;
+    private getItemWidth;
+    private handleClosedKeydown;
+    private handleOpenKeydown;
+    private refreshTriggerValues;
+    private initializeSelection;
+    /**
+     * Sets the selected option based on a value. If no option can be
+     * found with the designated value, the select trigger is cleared.
+     */
+    private setSelectionByValue;
+    private initKeyManager;
+    /** Sorts the selected values in the selected based on their order in the panel. */
+    private sortValues;
+    /**
+     * Highlights the selected item. If no option is selected, it will highlight
+     * the first item instead.
+     */
+    private highlightCorrectOption;
+    /** Scrolls the active option into view. */
+    private scrollActiveOptionIntoView;
+    /**
+     * Sets the x-offset of the overlay panel in relation to the trigger's top start corner.
+     * This must be adjusted to align the selected option text over the trigger text when
+     * the panel opens. Will change based on LTR or RTL text direction. Note that the offset
+     * can't be calculated until the panel has been attached, because we need to know the
+     * content width in order to constrain the panel within the viewport.
+     */
+    private calculateOverlayOffsetX;
+    /** Comparison function to specify which option is displayed. Defaults to object equality. */
+    private _compareWith;
+    private subscribeOnSearchChanges;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KbqTreeSelect, [null, null, null, null, null, null, null, { optional: true; }, { optional: true; }, { optional: true; }, { optional: true; }, { optional: true; self: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<KbqTreeSelect, "kbq-tree-select", ["mcTreeSelect"], { "disabled": { "alias": "disabled"; "required": false; }; "tabIndex": { "alias": "tabIndex"; "required": false; }; "hiddenItemsText": { "alias": "hiddenItemsText"; "required": false; }; "panelClass": { "alias": "panelClass"; "required": false; }; "backdropClass": { "alias": "backdropClass"; "required": false; }; "errorStateMatcher": { "alias": "errorStateMatcher"; "required": false; }; "sortComparator": { "alias": "sortComparator"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "required": { "alias": "required"; "required": false; }; "multiple": { "alias": "multiple"; "required": false; }; "autoSelect": { "alias": "autoSelect"; "required": false; }; "compareWith": { "alias": "compareWith"; "required": false; }; "id": { "alias": "id"; "required": false; }; "hasBackdrop": { "alias": "hasBackdrop"; "required": false; }; "hiddenItemsTextFormatter": { "alias": "hiddenItemsTextFormatter"; "required": false; }; }, { "openedChange": "openedChange"; "openedStream": "opened"; "closedStream": "closed"; "selectionChange": "selectionChange"; "valueChange": "valueChange"; }, ["cleaner", "customTrigger", "tree", "search"], ["kbq-tree-select-trigger", "kbq-cleaner", "[mcSelectSearch]", "[kbq-select-search-empty-result]", "kbq-tree-selection", "kbq-tree-select-footer,[kbq-tree-select-footer],[kbq-tree-selection-footer]"], false, never>;
+}
+export {};

package/tree-select/tree-select.module.d.ts

@@ -0,0 +1,14 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./tree-select.component";
+import * as i2 from "@angular/common";
+import * as i3 from "@angular/cdk/overlay";
+import * as i4 from "@koobiq/components/tree";
+import * as i5 from "@koobiq/components/icon";
+import * as i6 from "@koobiq/components/tags";
+import * as i7 from "@koobiq/components/core";
+import * as i8 from "@koobiq/components/select";
+export declare class KbqTreeSelectModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<KbqTreeSelectModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<KbqTreeSelectModule, [typeof i1.KbqTreeSelect, typeof i1.KbqTreeSelectTrigger, typeof i1.KbqTreeSelectFooter], [typeof i2.CommonModule, typeof i3.OverlayModule, typeof i4.KbqTreeModule, typeof i5.KbqIconModule, typeof i6.KbqTagsModule, typeof i7.KbqPseudoCheckboxModule, typeof i8.KbqSelectModule], [typeof i1.KbqTreeSelect, typeof i1.KbqTreeSelectTrigger, typeof i1.KbqTreeSelectFooter, typeof i2.CommonModule]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<KbqTreeSelectModule>;
+}