@alauda/ui 9.1.1-beta.3 → 9.1.1-beta.4

package/tooltip/base-tooltip.d.ts

@@ -0,0 +1,86 @@
+import { Overlay, OverlayRef } from '@angular/cdk/overlay';
+import { ComponentType } from '@angular/cdk/portal';
+import { AfterViewInit, ChangeDetectorRef, ElementRef, EventEmitter, NgZone, OnDestroy, Renderer2, TemplateRef, ViewContainerRef } from '@angular/core';
+import { ReplaySubject, Subject } from 'rxjs';
+import { AnimationType } from './animations';
+import { TooltipComponent } from './tooltip.component';
+import { TooltipTrigger, TooltipType } from './tooltip.types';
+import * as i0 from "@angular/core";
+export interface TooltipInterface {
+    content: TemplateRef<any> | string;
+    context: any;
+    class: string;
+    type: TooltipType;
+    position: string;
+    trigger: TooltipTrigger;
+    disabled: boolean;
+    hideOnClick: boolean;
+    visibleChange: EventEmitter<boolean>;
+}
+export declare const DISPLAY_DELAY = 50;
+export declare const HIDDEN_DELAY = 150;
+export declare class BaseTooltip<T = any> implements TooltipInterface, AfterViewInit, OnDestroy {
+    protected overlay: Overlay;
+    protected viewContainerRef: ViewContainerRef;
+    protected elRef: ElementRef<HTMLInputElement>;
+    protected renderer: Renderer2;
+    protected cdr: ChangeDetectorRef;
+    protected ngZone: NgZone;
+    set content(value: TemplateRef<any> | string);
+    get content(): TemplateRef<any> | string;
+    set context(value: T);
+    get context(): T;
+    set class(value: string);
+    set type(value: TooltipType);
+    set position(value: string);
+    get position(): string;
+    set trigger(value: TooltipTrigger);
+    get trigger(): TooltipTrigger;
+    set disabled(value: boolean);
+    get disabled(): boolean;
+    hideOnClick: boolean;
+    animationType: AnimationType;
+    visibleChange: EventEmitter<boolean>;
+    overlayRef: OverlayRef;
+    protected componentClass: ComponentType<any>;
+    protected componentIns: TooltipComponent;
+    protected hostHovered: boolean;
+    protected tooltipHovered: boolean;
+    protected listeners: Array<() => void>;
+    protected unlistenBody: () => void;
+    protected inputContent$$: ReplaySubject<string | TemplateRef<any>>;
+    protected inputType$$: ReplaySubject<TooltipType>;
+    protected inputPosition$$: ReplaySubject<string>;
+    protected inputClass$$: ReplaySubject<string>;
+    protected inputContext$$: ReplaySubject<any>;
+    protected tooltipChanged$: import("rxjs").Observable<any>;
+    protected destroy$: Subject<unknown>;
+    protected _position: string;
+    protected _trigger: TooltipTrigger;
+    protected _disabled: boolean;
+    protected _context: T;
+    protected _content: TemplateRef<unknown> | string;
+    get isCreated(): boolean;
+    constructor(overlay: Overlay, viewContainerRef: ViewContainerRef, elRef: ElementRef<HTMLInputElement>, renderer: Renderer2, cdr: ChangeDetectorRef, ngZone: NgZone);
+    private _updateTransformOrigin;
+    _createTooltip(): void;
+    _disposeTooltip(): void;
+    toggleTooltip(): void;
+    show(): void;
+    hide(): void;
+    updatePosition(): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    protected updateListeners(): void;
+    protected clearListeners(): void;
+    protected createOverlay(): OverlayRef;
+    protected onMouseEnter(): Promise<void>;
+    protected onMouseLeave(): Promise<void>;
+    protected onTooltipHovered(hovered: boolean): Promise<void>;
+    protected onClick(): void;
+    protected onBodyClick(event: Event): void;
+    protected onFocus(): void;
+    protected onBlur(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaseTooltip<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BaseTooltip<any>, never, never, {}, {}, never, never, true, never>;
+}

package/tooltip/index.d.ts

@@ -0,0 +1,8 @@
+export * from './base-tooltip';
+export * from './tooltip.component';
+export * from './tooltip.directive';
+export * from './tooltip.module';
+export * from './tooltip.types';
+export * from './tooltip-active.directive';
+export * from './tooltip-copy.directive';
+export * from './tooltip-intl';

package/tooltip/tooltip-active.directive.d.ts

@@ -0,0 +1,16 @@
+import { ElementRef, OnDestroy, Renderer2 } from '@angular/core';
+import { Subject } from 'rxjs';
+import { BaseTooltip } from './base-tooltip';
+import * as i0 from "@angular/core";
+export declare class TooltipActiveDirective implements OnDestroy {
+    private readonly el;
+    private readonly renderer;
+    customClass: string[] | string;
+    destroy$: Subject<unknown>;
+    constructor(tooltipDirective: BaseTooltip, el: ElementRef, renderer: Renderer2);
+    ngOnDestroy(): void;
+    private addClass;
+    private removeClass;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TooltipActiveDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TooltipActiveDirective, "[auiTooltipActive]", never, { "customClass": { "alias": "auiTooltipActive"; "required": false; }; }, {}, never, never, true, never>;
+}

package/tooltip/tooltip-copy.directive.d.ts

@@ -0,0 +1,26 @@
+import { Overlay } from '@angular/cdk/overlay';
+import { ChangeDetectorRef, ElementRef, NgZone, OnInit, Renderer2, ViewContainerRef } from '@angular/core';
+import { BaseTooltip } from './base-tooltip';
+import { TooltipCopyIntl } from './tooltip-intl';
+import * as i0 from "@angular/core";
+export declare class TooltipCopyDirective extends BaseTooltip implements OnInit {
+    private readonly toolTipIntl;
+    className: boolean;
+    get auiTooltipCopy(): string;
+    set auiTooltipCopy(value: string);
+    get auiTooltipCopyTip(): string;
+    set auiTooltipCopyTip(value: string);
+    get auiTooltipCopySuccessTip(): string;
+    set auiTooltipCopySuccessTip(value: string);
+    get auiTooltipCopyFailTip(): string;
+    set auiTooltipCopyFailTip(value: string);
+    private _copyText;
+    private _copyTip;
+    private _copySuccessTip;
+    private _copyFailTip;
+    constructor(overlay: Overlay, viewContainerRef: ViewContainerRef, elRef: ElementRef, renderer: Renderer2, cdr: ChangeDetectorRef, ngZone: NgZone, toolTipIntl: TooltipCopyIntl);
+    ngOnInit(): void;
+    onSourceClick(): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TooltipCopyDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TooltipCopyDirective, "[auiTooltipCopy]", never, { "position": { "alias": "auiTooltipPosition"; "required": false; }; "disabled": { "alias": "auiTooltipDisabled"; "required": false; }; "auiTooltipCopy": { "alias": "auiTooltipCopy"; "required": false; }; "auiTooltipCopyTip": { "alias": "auiTooltipCopyTip"; "required": false; }; "auiTooltipCopySuccessTip": { "alias": "auiTooltipCopySuccessTip"; "required": false; }; "auiTooltipCopyFailTip": { "alias": "auiTooltipCopyFailTip"; "required": false; }; }, {}, never, never, true, never>;
+}

package/tooltip/tooltip-intl.d.ts

@@ -0,0 +1,11 @@
+import * as i0 from "@angular/core";
+/**
+ * Texts to render on the code editor.
+ */
+export declare class TooltipCopyIntl {
+    copyTip: string;
+    copySuccessTip: string;
+    copyFailTip: string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TooltipCopyIntl, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TooltipCopyIntl>;
+}

package/tooltip/tooltip.component.d.ts

@@ -0,0 +1,46 @@
+import { AnimationEvent } from '@angular/animations';
+import { ChangeDetectorRef, ElementRef, OnDestroy, TemplateRef } from '@angular/core';
+import { Observable, Subject, BehaviorSubject } from 'rxjs';
+import { Bem } from '../internal/utils';
+import { AnimationType } from './animations';
+import { TooltipType } from './tooltip.types';
+import * as i0 from "@angular/core";
+export declare class TooltipComponent implements OnDestroy {
+    elRef: ElementRef<HTMLElement>;
+    cdr: ChangeDetectorRef;
+    text: string;
+    template: TemplateRef<any>;
+    bem: Bem;
+    showHide: string;
+    animationType: AnimationType;
+    inputContent$: Observable<TemplateRef<any> | string>;
+    inputType$: Observable<TooltipType>;
+    inputPosition$: Observable<string>;
+    inputClass$: Observable<string>;
+    inputContext$: Observable<any>;
+    text$: Observable<string>;
+    template$: Observable<TemplateRef<any>>;
+    class$: Observable<string>;
+    context$: Observable<any>;
+    hover$: Subject<boolean>;
+    destroy$: Subject<unknown>;
+    animating$$: BehaviorSubject<boolean>;
+    hide$: Subject<unknown>;
+    beforeHide$: Subject<unknown>;
+    beforeShow$: Subject<unknown>;
+    constructor(elRef: ElementRef<HTMLElement>, cdr: ChangeDetectorRef);
+    ngOnDestroy(): void;
+    setupInputs(inputs: {
+        inputContent$: Observable<TemplateRef<any> | string>;
+        inputType$: Observable<TooltipType>;
+        inputPosition$: Observable<string>;
+        inputClass$: Observable<string>;
+        inputContext$: Observable<any>;
+        animationType?: string;
+    }): void;
+    onAnimation(event: AnimationEvent): void;
+    show(): void;
+    hide(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TooltipComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TooltipComponent, "aui-tooltip", never, {}, {}, never, never, true, never>;
+}

package/tooltip/tooltip.directive.d.ts

@@ -0,0 +1,10 @@
+import { EventEmitter } from '@angular/core';
+import { AnimationType } from './animations';
+import { BaseTooltip } from './base-tooltip';
+import * as i0 from "@angular/core";
+export declare class TooltipDirective extends BaseTooltip {
+    visibleChange: EventEmitter<boolean>;
+    animationType: AnimationType;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TooltipDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TooltipDirective, "[auiTooltip]", ["auiTooltip"], { "content": { "alias": "auiTooltip"; "required": false; }; "context": { "alias": "auiTooltipContext"; "required": false; }; "class": { "alias": "auiTooltipClass"; "required": false; }; "type": { "alias": "auiTooltipType"; "required": false; }; "position": { "alias": "auiTooltipPosition"; "required": false; }; "trigger": { "alias": "auiTooltipTrigger"; "required": false; }; "disabled": { "alias": "auiTooltipDisabled"; "required": false; }; "hideOnClick": { "alias": "auiTooltipHideOnClick"; "required": false; }; "animationType": { "alias": "auiTooltipAnimType"; "required": false; }; }, { "visibleChange": "auiTooltipVisibleChange"; }, never, never, true, never>;
+}

package/tooltip/tooltip.module.d.ts

@@ -0,0 +1,16 @@
+import { TooltipActiveDirective } from './tooltip-active.directive';
+import { TooltipCopyDirective } from './tooltip-copy.directive';
+import { TooltipDirective } from './tooltip.directive';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "@angular/cdk/overlay";
+import * as i3 from "./tooltip.directive";
+import * as i4 from "./tooltip.component";
+import * as i5 from "./tooltip-active.directive";
+import * as i6 from "./tooltip-copy.directive";
+export declare class TooltipModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<TooltipModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<TooltipModule, never, [typeof i1.CommonModule, typeof i2.OverlayModule, typeof i3.TooltipDirective, typeof i4.TooltipComponent, typeof i5.TooltipActiveDirective, typeof i6.TooltipCopyDirective], [typeof i3.TooltipDirective, typeof i5.TooltipActiveDirective, typeof i6.TooltipCopyDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<TooltipModule>;
+}
+export declare const TOOLTIP_MODULE: readonly [typeof TooltipDirective, typeof TooltipActiveDirective, typeof TooltipCopyDirective];

package/tooltip/tooltip.types.d.ts

@@ -0,0 +1,16 @@
+export declare enum TooltipType {
+    Default = "default",
+    Primary = "primary",
+    Success = "success",
+    Warning = "warning",
+    Error = "error",
+    Info = "info",
+    Plain = "plain",
+    Empty = "empty"
+}
+export declare enum TooltipTrigger {
+    Hover = "hover",
+    Click = "click",
+    Focus = "focus",
+    Manual = "manual"
+}

package/tooltip/utils/index.d.ts

@@ -0,0 +1,15 @@
+import { HorizontalConnectionPos, OriginConnectionPosition, OverlayConnectionPosition, VerticalConnectionPos } from '@angular/cdk/overlay';
+export declare function getOriginPosition(position: string): {
+    main: OriginConnectionPosition;
+    fallback: OriginConnectionPosition;
+};
+export declare function getOverlayPosition(position: string): {
+    main: OverlayConnectionPosition;
+    fallback: OverlayConnectionPosition;
+};
+export declare function invertHorizontal(dir: HorizontalConnectionPos): HorizontalConnectionPos;
+export declare function invertVertical(dir: VerticalConnectionPos): VerticalConnectionPos;
+export declare function invertPosition(x: HorizontalConnectionPos, y: VerticalConnectionPos): {
+    x: HorizontalConnectionPos;
+    y: VerticalConnectionPos;
+};

package/tree-select/index.d.ts

@@ -0,0 +1,4 @@
+export * from './tree-node-placeholder.component';
+export * from './tree-select.component';
+export * from './tree-select.module';
+export * from './tree-select.types';

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

@@ -0,0 +1,5 @@
+import * as i0 from "@angular/core";
+export declare class TreeNodePlaceholderComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<TreeNodePlaceholderComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TreeNodePlaceholderComponent, "aui-tree-node-placeholder", never, {}, {}, never, ["*"], true, never>;
+}

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

@@ -0,0 +1,94 @@
+import { AfterViewInit, ChangeDetectorRef, ElementRef, EventEmitter, OnDestroy, QueryList } from '@angular/core';
+import { Observable } from 'rxjs';
+import { CommonFormControl } from '../form';
+import { InputComponent } from '../input/input.component';
+import { Bem } from '../internal/utils';
+import { TrackFn } from '../select/select.types';
+import { TooltipDirective } from '../tooltip/tooltip.directive';
+import { TreeNode } from './tree-select.types';
+import * as i0 from "@angular/core";
+export declare class TreeSelectComponent<T = unknown> extends CommonFormControl<T> {
+    get nodesData(): TreeNode<T>[];
+    set nodesData(val: TreeNode<T>[]);
+    loading: boolean;
+    placeholder: string;
+    filterable: boolean;
+    clearable: boolean;
+    leafOnly: boolean;
+    filterFn: (filterString: string, node: TreeNode<T>) => boolean;
+    trackFn: TrackFn<T>;
+    labelFn?: (value: T) => string;
+    filterChange: EventEmitter<string>;
+    show: EventEmitter<void>;
+    hide: EventEmitter<void>;
+    protected selectRef: ElementRef<HTMLElement>;
+    protected tooltipRef: TooltipDirective;
+    nodeListRef: ElementRef<HTMLElement>;
+    inputRef: InputComponent;
+    private _nodesData;
+    private _filterString;
+    private readonly filterString$$;
+    filterString$: Observable<string>;
+    containerWidth: string;
+    displayText: string;
+    flattedNodes: Array<TreeNode<T>>;
+    get isClearable(): string;
+    get opened(): boolean;
+    get inputReadonly(): boolean;
+    get filterString(): string;
+    set filterString(val: string);
+    updatePosition(): void;
+    onVisibleNodes(visible: boolean): void;
+    onInput(event: Event): void;
+    onNodeClick(node: TreeNodeComponent<T>): void;
+    getVisibleNodeCount(): number;
+    selectNode(node: TreeNodeComponent<T>): void;
+    onKeyDown(event: KeyboardEvent): void;
+    openOption(): void;
+    closeOption(): void;
+    updateSelectDisplay(value: any): void;
+    clearValue(event: Event): void;
+    protected valueIn(v: T): T;
+    getPlaceholder(): string;
+    getInputValue(): string;
+    trackByLabel: (_: number, node: TreeNode<T>) => string;
+    private flatNodesData;
+    private getLabelFromNode;
+    private _filterFn;
+    private _trackFn;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TreeSelectComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TreeSelectComponent<any>, "aui-tree-select", never, { "nodesData": { "alias": "nodesData"; "required": false; }; "loading": { "alias": "loading"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "filterable": { "alias": "filterable"; "required": false; }; "clearable": { "alias": "clearable"; "required": false; }; "leafOnly": { "alias": "leafOnly"; "required": false; }; "filterFn": { "alias": "filterFn"; "required": false; }; "trackFn": { "alias": "trackFn"; "required": false; }; "labelFn": { "alias": "labelFn"; "required": false; }; }, { "filterChange": "filterChange"; "show": "show"; "hide": "hide"; }, never, ["aui-tree-node-placeholder"], true, never>;
+    static ngAcceptInputType_filterable: unknown;
+    static ngAcceptInputType_clearable: unknown;
+    static ngAcceptInputType_leafOnly: unknown;
+}
+export declare class TreeNodeComponent<T> implements AfterViewInit, OnDestroy {
+    private readonly cdr;
+    bem: Bem;
+    private _nodeData;
+    private readonly nodeData$$;
+    private readonly destroy$$;
+    get nodeData(): TreeNode<T>;
+    set nodeData(val: TreeNode<T>);
+    leafOnly: boolean;
+    titleRef: ElementRef<HTMLElement>;
+    childNodes: QueryList<TreeNodeComponent<T>>;
+    selected: boolean;
+    visible: boolean;
+    isLeaf: boolean;
+    private readonly select;
+    selected$: Observable<boolean>;
+    selfVisible$: Observable<boolean>;
+    visible$: Observable<boolean>;
+    constructor(select: TreeSelectComponent<T>, cdr: ChangeDetectorRef);
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    onClick(): void;
+    switchExpanded(): void;
+    getIcon(): string;
+    trackByLabel(_: number, data: TreeNode<T>): string;
+    scrollToNode(node: TreeNodeComponent<T>): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TreeNodeComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TreeNodeComponent<any>, "aui-tree-node", never, { "nodeData": { "alias": "nodeData"; "required": false; }; "leafOnly": { "alias": "leafOnly"; "required": false; }; }, {}, never, never, true, never>;
+    static ngAcceptInputType_leafOnly: unknown;
+}

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

@@ -0,0 +1,12 @@
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "../tooltip/tooltip.module";
+import * as i3 from "../icon/icon.module";
+import * as i4 from "../input/input.module";
+import * as i5 from "./tree-select.component";
+import * as i6 from "./tree-node-placeholder.component";
+export declare class TreeSelectModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<TreeSelectModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<TreeSelectModule, never, [typeof i1.CommonModule, typeof i2.TooltipModule, typeof i3.IconModule, typeof i4.InputModule, typeof i5.TreeSelectComponent, typeof i5.TreeNodeComponent, typeof i6.TreeNodePlaceholderComponent], [typeof i5.TreeSelectComponent, typeof i5.TreeNodeComponent, typeof i6.TreeNodePlaceholderComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<TreeSelectModule>;
+}

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

@@ -0,0 +1,11 @@
+export type NodeFilterFn<T> = (filter: string, node: TreeNode<T>) => boolean;
+export interface TreeNode<T = unknown> {
+    label: string;
+    value: T;
+    children?: Array<TreeNode<T>>;
+    disabled?: boolean;
+    expanded?: boolean;
+    icon?: string;
+    expandedIcon?: string;
+    loading?: boolean;
+}