@alauda-fe/common 1.0.0-next.0

package/esm2022/multi-search/form/component.mjs

@@ -0,0 +1,379 @@
+import { __decorate, __metadata } from "tslib";
+import { IconComponent, InputComponent, TagComponent } from '@alauda/ui';
+import { AsyncPipe, NgClass, NgFor, NgIf } from '@angular/common';
+import { ChangeDetectionStrategy, ChangeDetectorRef, Component, ElementRef, EventEmitter, Input, Output, ViewChild, } from '@angular/core';
+import { FormsModule } from '@angular/forms';
+import { cloneDeep, isEmpty, isEqual, set } from 'lodash-es';
+import { BehaviorSubject, combineLatest, distinctUntilChanged, fromEvent, map, merge, Observable, scan, Subject, take, takeUntil, tap, } from 'rxjs';
+import { ObservableInput, publishRef } from '../../core';
+import { PurePipe } from '../../scm';
+import { MultiSearchActionInputComponent } from '../action-input/component';
+import { MultiSearchTagsComponent } from '../multi-search-tags/component';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/forms";
+const _c0 = ["inputRef"];
+const _c1 = ["tagsRef"];
+const _c2 = ["multiSearch"];
+function MultiSearchComponent_div_12_Template(rf, ctx) { if (rf & 1) {
+    const _r5 = i0.ɵɵgetCurrentView();
+    i0.ɵɵelementStart(0, "div", 10)(1, "aui-icon", 11);
+    i0.ɵɵlistener("click", function MultiSearchComponent_div_12_Template_aui_icon_click_1_listener($event) { i0.ɵɵrestoreView(_r5); const ctx_r4 = i0.ɵɵnextContext(); ctx_r4.clearConditions(); ctx_r4.doSearch(); return i0.ɵɵresetView($event.stopPropagation()); });
+    i0.ɵɵelementEnd()();
+} if (rf & 2) {
+    const ctx_r3 = i0.ɵɵnextContext();
+    i0.ɵɵadvance(1);
+    i0.ɵɵproperty("ngClass", ctx_r3.CLEAR_ICON_CLASS);
+} }
+const _c3 = function (a0) { return { "search-focus": a0 }; };
+const _c4 = function (a0, a1) { return { "tags-width-with-delete": a0, "tags-width": a1 }; };
+export const DEFAULT_OPERATOR = '=';
+export class MultiSearchComponent {
+    get inputComponent() {
+        return this.noDeletingCondition && this.noEditingCondition
+            ? this.normalInputComponent
+            : this.tagsComponent?.inputComponent;
+    }
+    constructor(cdr) {
+        this.cdr = cdr;
+        this.placeholder = '';
+        this.conditionCreatable = false;
+        // 搜索操作
+        this.search = new EventEmitter();
+        // 条件变化
+        this.conditionsChange = new EventEmitter();
+        // 当前multi-search组件是否focus
+        this.focus$$ = new BehaviorSubject(false);
+        this.destroy$$ = new Subject();
+        this.actionScanner$$ = new Subject();
+        this.existingConditions = [];
+        this.existingConditions$ = merge(combineLatest([this.conditions$, this.conditionConfig$]).pipe(map(([conditions, conditionConfig]) => {
+            const res = conditions?.map(condition => {
+                const exist = this.existingConditions?.find(exist => exist.condition.value === condition.condition);
+                const config = conditionConfig?.find(config => config.condition.value === condition.condition);
+                // 所继承的数据，若已存在exist，则继承exist；若不存在，则继承config
+                // 此处的继承是为了防止外界conditions数据的变化导致操作状态刷新
+                // 因此，除了conditions数据外的附加数据，都应该继承
+                const inherit = {
+                    ...exist,
+                    ...config,
+                };
+                return isEmpty(inherit)
+                    ? {
+                        condition: { value: condition.condition },
+                        operator: condition.operator,
+                        selectedValues: condition.values?.map(value => ({
+                            value,
+                        })),
+                    }
+                    : {
+                        ...inherit,
+                        operator: condition.operator,
+                        selectedValues: condition.values?.map(value => {
+                            const find = inherit.values?.find(inheritValue => inheritValue.value === value);
+                            return find
+                                ? { ...find }
+                                : {
+                                    value,
+                                };
+                        }),
+                    };
+            }) || [];
+            return (_) => res;
+        })), this.actionScanner$$).pipe(scan((acc, cur) => cur(acc), []), tap(existingConditions => {
+            this.existingConditions = existingConditions;
+        }), publishRef());
+        this.noEditingCondition = true;
+        this.noEditingCondition$ = this.existingConditions$.pipe(map(existingConditions => existingConditions?.every(condition => !condition.isEditing)), tap(noEditingCondition => (this.noEditingCondition = noEditingCondition)), publishRef());
+        this.noDeletingCondition = true;
+        this.noDeletingCondition$ = this.existingConditions$.pipe(map(existingConditions => existingConditions?.every(condition => !condition.isDeleting)), tap(noDeletingCondition => (this.noDeletingCondition = noDeletingCondition)), publishRef());
+        this.addedInputShouldHidden$ = combineLatest([
+            this.noEditingCondition$,
+            this.noDeletingCondition$,
+            this.existingConditions$,
+        ]).pipe(map(([noEditingCondition, noDeletingCondition, existingConditions]) => {
+            return ((!noEditingCondition || !noDeletingCondition) &&
+                existingConditions.length !== 0);
+        }), publishRef());
+        this.CLEAR_ICON_CLASS = 'search-clear-icon';
+        this.SEARCH_ICON_CLASS = 'search-icon';
+        this.existingConditions$
+            .pipe(takeUntil(this.destroy$$), distinctUntilChanged((a, b) => a?.length === b?.length))
+            .subscribe(existingConditions => {
+            this.conditionsChange.emit(this.getConditionModel(existingConditions));
+        });
+        // 此处的click事件监听使用了捕获而非冒泡，是为了让事件触发的时机先于tag.click
+        // 若tag.click先触发，会导致element.contains()判断出错
+        fromEvent(document.body, 'click', { capture: true })
+            .pipe(takeUntil(this.destroy$$))
+            .subscribe(event => {
+            const target = event.target;
+            if (this.isSearchBtn(target)) {
+                this.manualComplete(false, true);
+                this.inputComponent.toolTipHide();
+                return;
+            }
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-call
+            if (this.multiSearchRef?.nativeElement?.contains(target)) {
+                // 当点击区域为multi-search组件，自动聚焦
+                // 对于操作按钮，只做hidden toolTip
+                if (this.notActionElement(target)) {
+                    if (document.activeElement !== this.inputComponent?.inputElement) {
+                        const isFocus = this.focus$$.value;
+                        this.manualFocus(isFocus);
+                    }
+                    this.inputComponent.toolTipShow();
+                }
+                else {
+                    this.manualFocus(true);
+                    // this.inputComponent.toolTipHide();
+                }
+                // 当点击区域为非tooltip的其他区域时，自动收缩
+            }
+            else if (this.notTooltipContent(target)) {
+                this.manualBlur();
+            }
+        });
+    }
+    isSearchBtn(element) {
+        return this.checkElement(element, element => element?.className?.includes?.(this.SEARCH_ICON_CLASS));
+    }
+    notActionElement(element) {
+        return !this.checkElement(element, element => element?.className?.includes?.(this.CLEAR_ICON_CLASS) ||
+            element?.className?.includes?.(this.SEARCH_ICON_CLASS) ||
+            element?.className?.includes?.('aui-tag__close'));
+    }
+    notTooltipContent(element) {
+        return !this.checkElement(element, element => element.tagName === 'AUI-TOOLTIP');
+    }
+    checkElement(element, fn) {
+        while (element && !fn(element)) {
+            element = element.parentElement;
+        }
+        return !!element;
+    }
+    manualComplete(toContinue = false, manualFocus = false) {
+        this.inputComponent?.ifComplete(toContinue, manualFocus);
+    }
+    manualFocus(silence) {
+        this.setFocus(true);
+        this.inputComponent?.manualFocus(silence);
+    }
+    setFocus(focus) {
+        this.focus$$.next(focus);
+    }
+    manualBlur() {
+        this.setFocus(false);
+        this.inputComponent?.manualBlur();
+    }
+    // 搜索操作
+    doSearch() {
+        this.existingConditions$
+            .pipe(take(1), takeUntil(this.destroy$$))
+            .subscribe(exists => {
+            this.search.emit(this.getConditionModel(exists?.filter(exist => !this.conditionInAction(exist))));
+        });
+    }
+    // 清除所有已选条件
+    clearConditions() {
+        this.addedCondition = null;
+        this.cdr.markForCheck();
+        this.actionScanner$$.next((_) => []);
+    }
+    // 移除当前条件
+    removeCondition(condition) {
+        const remove = (existingConditions) => {
+            const idx = existingConditions.findIndex(con => con.condition.value === condition.condition.value);
+            existingConditions.splice(idx, 1);
+            return [...existingConditions];
+        };
+        this.actionScanner$$.next(remove);
+    }
+    // 更新条件
+    updateCondition(condition, index) {
+        const _update = (existingConditions) => {
+            if (condition) {
+                existingConditions.splice(index, 1, condition);
+            }
+            else {
+                existingConditions.splice(index, 1);
+            }
+            return [...existingConditions];
+        };
+        this.actionScanner$$.next(_update);
+    }
+    // 添加condition
+    addCondition(activeCondition) {
+        const _add = (existingConditions) => {
+            existingConditions.push(activeCondition);
+            return [...existingConditions];
+        };
+        this.actionScanner$$.next(_add);
+    }
+    // 设置condition的状态为编辑态
+    setConditionEditing(condition) {
+        if (this.isGrammarCustomCondition(condition))
+            return;
+        const _update = (existingConditions) => {
+            if (!existingConditions)
+                return;
+            const idx = existingConditions.findIndex(con => con.condition.value === condition.condition.value);
+            const conditionsExceptCur = [
+                ...(existingConditions.slice(0, idx) || []),
+                ...(existingConditions.slice(idx + 1) || []),
+            ];
+            const alreadyHaveAction = conditionsExceptCur.some(con => this.conditionInAction(con));
+            // 当已经存在操作中的condition时，会继续维护之前操作，中止新的操作行为
+            // 上述处理逻辑主要是为了避免操作到一半（比如未选择operator、未选择condition时）就切换至另一个condition操作，此时该未完成的操作应该如何处理，暂未给定。
+            if (alreadyHaveAction || this.addedCondition)
+                return existingConditions;
+            const find = existingConditions[idx];
+            // 将当前所操作condition的状态重置为editing
+            find.isDeleting = false;
+            find.isEditing = true;
+            find.actionModel = cloneDeep(find);
+            return [...existingConditions];
+        };
+        this.actionScanner$$.next(_update);
+    }
+    // 设置condition的状态为删除态
+    setConditionDeleting(index) {
+        const _delete = (existingConditions) => {
+            const condition = Number.isInteger(index)
+                ? existingConditions[index]
+                : existingConditions.at(-1);
+            if (condition) {
+                set(condition, 'isDeleting', true);
+                condition.actionModel = cloneDeep(condition);
+            }
+            return [...existingConditions];
+        };
+        this.actionScanner$$.next(_delete);
+    }
+    complete({ activeCondition, toContinue, manualFocus, index, }) {
+        if (activeCondition) {
+            activeCondition.isEditing = false;
+            activeCondition.isDeleting = false;
+        }
+        if (Number.isInteger(index)) {
+            this.updateCondition(activeCondition, index);
+        }
+        else if (activeCondition) {
+            this.addCondition(activeCondition);
+        }
+        // 自动聚焦
+        if (manualFocus) {
+            this.manualFocus(!toContinue);
+        }
+    }
+    isGrammarCustomCondition(condition) {
+        const inConfig = this.conditionConfig.some(config => isEqual(condition.condition, config.condition));
+        // 如果当前condition不在config中，且operator不为默认值，则代表当前condition是用户通过语法自定义的，此时不允许通过UI修改
+        // 考虑到未来会允许用户输入创建condition，此时是允许用户通过UI再次修改的。此类情况的特性：!inConfig && operator === DEFAULT_OPERATOR
+        return !inConfig && condition.operator !== DEFAULT_OPERATOR;
+    }
+    getConditionModel(conditions) {
+        return conditions?.map(condition => ({
+            condition: condition.condition.value,
+            operator: condition.operator,
+            values: condition.selectedValues?.map(value => value.value) || [],
+        }));
+    }
+    conditionInAction(condition) {
+        return condition.isEditing || condition.isDeleting;
+    }
+    ngOnDestroy() {
+        this.destroy$$.next();
+    }
+    static { this.ɵfac = function MultiSearchComponent_Factory(t) { return new (t || MultiSearchComponent)(i0.ɵɵdirectiveInject(i0.ChangeDetectorRef)); }; }
+    static { this.ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: MultiSearchComponent, selectors: [["acl-multi-search"]], viewQuery: function MultiSearchComponent_Query(rf, ctx) { if (rf & 1) {
+            i0.ɵɵviewQuery(_c0, 5);
+            i0.ɵɵviewQuery(_c1, 5);
+            i0.ɵɵviewQuery(_c2, 7);
+        } if (rf & 2) {
+            let _t;
+            i0.ɵɵqueryRefresh(_t = i0.ɵɵloadQuery()) && (ctx.normalInputComponent = _t.first);
+            i0.ɵɵqueryRefresh(_t = i0.ɵɵloadQuery()) && (ctx.tagsComponent = _t.first);
+            i0.ɵɵqueryRefresh(_t = i0.ɵɵloadQuery()) && (ctx.multiSearchRef = _t.first);
+        } }, inputs: { placeholder: "placeholder", conditionCreatable: "conditionCreatable", conditions: "conditions", conditionConfig: "conditionConfig" }, outputs: { search: "search", conditionsChange: "conditionsChange" }, standalone: true, features: [i0.ɵɵStandaloneFeature], decls: 17, vars: 32, consts: [[1, "aui-input", "multi-search", 3, "ngClass"], ["multiSearch", ""], [3, "ngClass", "placeholder", "conditionCreatable", "existingConditions", "conditionConfig", "removeCondition", "setConditionEditing", "setConditionDeleting", "search", "completed"], ["tagsRef", ""], [1, "input-wrapper", 3, "isEditing", "hidden", "placeholder", "conditionCreatable", "conditionConfig", "existingConditions", "ngModel", "ngModelChange", "completed", "delete", "search"], ["inputRef", ""], [1, "search-suffix"], ["class", "search-clear", 4, "ngIf"], [1, "suffix-wrapper"], ["icon", "magnifier", 1, "tw-text-n-4", "tw-cursor-pointer", 3, "ngClass", "click"], [1, "search-clear"], ["icon", "xmark_small", "size", "14", 1, "tw-text-n-4", "tw-cursor-pointer", 3, "ngClass", "click"]], template: function MultiSearchComponent_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵelementStart(0, "div", 0, 1);
+            i0.ɵɵpipe(2, "async");
+            i0.ɵɵelementStart(3, "acl-multi-search-tags", 2, 3);
+            i0.ɵɵlistener("removeCondition", function MultiSearchComponent_Template_acl_multi_search_tags_removeCondition_3_listener($event) { return ctx.removeCondition($event); })("setConditionEditing", function MultiSearchComponent_Template_acl_multi_search_tags_setConditionEditing_3_listener($event) { return ctx.setConditionEditing($event); })("setConditionDeleting", function MultiSearchComponent_Template_acl_multi_search_tags_setConditionDeleting_3_listener($event) { return ctx.setConditionDeleting($event); })("search", function MultiSearchComponent_Template_acl_multi_search_tags_search_3_listener() { return ctx.doSearch(); })("completed", function MultiSearchComponent_Template_acl_multi_search_tags_completed_3_listener($event) { return ctx.complete($event); });
+            i0.ɵɵpipe(5, "async");
+            i0.ɵɵpipe(6, "async");
+            i0.ɵɵelementStart(7, "acl-multi-search-action-input", 4, 5);
+            i0.ɵɵlistener("ngModelChange", function MultiSearchComponent_Template_acl_multi_search_action_input_ngModelChange_7_listener($event) { return ctx.addedCondition = $event; })("completed", function MultiSearchComponent_Template_acl_multi_search_action_input_completed_7_listener($event) { return ctx.complete($event); })("delete", function MultiSearchComponent_Template_acl_multi_search_action_input_delete_7_listener() { return ctx.setConditionDeleting(); })("search", function MultiSearchComponent_Template_acl_multi_search_action_input_search_7_listener() { return ctx.doSearch(); });
+            i0.ɵɵpipe(9, "async");
+            i0.ɵɵpipe(10, "async");
+            i0.ɵɵelementEnd()();
+            i0.ɵɵelementStart(11, "div", 6);
+            i0.ɵɵtemplate(12, MultiSearchComponent_div_12_Template, 2, 1, "div", 7);
+            i0.ɵɵpipe(13, "async");
+            i0.ɵɵelementStart(14, "div", 6)(15, "div", 8)(16, "aui-icon", 9);
+            i0.ɵɵlistener("click", function MultiSearchComponent_Template_aui_icon_click_16_listener($event) { ctx.doSearch(); return $event.stopPropagation(); });
+            i0.ɵɵelementEnd()()()()();
+        } if (rf & 2) {
+            let tmp_1_0;
+            let tmp_13_0;
+            i0.ɵɵproperty("ngClass", i0.ɵɵpureFunction1(27, _c3, i0.ɵɵpipeBind1(2, 15, ctx.focus$$)));
+            i0.ɵɵadvance(3);
+            i0.ɵɵproperty("ngClass", i0.ɵɵpureFunction2(29, _c4, (tmp_1_0 = i0.ɵɵpipeBind1(5, 17, ctx.existingConditions$)) == null ? null : tmp_1_0.length, !((tmp_1_0 = i0.ɵɵpipeBind1(6, 19, ctx.existingConditions$)) == null ? null : tmp_1_0.length)))("placeholder", ctx.placeholder)("conditionCreatable", ctx.conditionCreatable)("existingConditions", ctx.existingConditions)("conditionConfig", ctx.conditionConfig);
+            i0.ɵɵadvance(4);
+            i0.ɵɵproperty("isEditing", true)("hidden", i0.ɵɵpipeBind1(9, 21, ctx.addedInputShouldHidden$))("placeholder", ctx.placeholder)("conditionCreatable", ctx.conditionCreatable)("conditionConfig", ctx.conditionConfig)("existingConditions", i0.ɵɵpipeBind1(10, 23, ctx.existingConditions$))("ngModel", ctx.addedCondition);
+            i0.ɵɵadvance(5);
+            i0.ɵɵproperty("ngIf", (tmp_13_0 = i0.ɵɵpipeBind1(13, 25, ctx.existingConditions$)) == null ? null : tmp_13_0.length);
+            i0.ɵɵadvance(4);
+            i0.ɵɵproperty("ngClass", ctx.SEARCH_ICON_CLASS);
+        } }, dependencies: [NgClass,
+            AsyncPipe,
+            MultiSearchActionInputComponent,
+            MultiSearchTagsComponent,
+            NgIf,
+            FormsModule, i1.NgControlStatus, i1.NgModel, IconComponent], styles: ["[_nghost-%COMP%]{min-width:0}.multi-search[_ngcontent-%COMP%]{min-width:240px;height:max-content;display:flex;align-items:stretch;padding:0;overflow-y:auto}.multi-search[_ngcontent-%COMP%]   .tags-width[_ngcontent-%COMP%]{width:calc(100% - 30px)}.multi-search[_ngcontent-%COMP%]   .tags-width-with-delete[_ngcontent-%COMP%]{width:calc(100% - 48px)}.multi-search[_ngcontent-%COMP%]   .search-clear[_ngcontent-%COMP%]{width:18px;display:flex;align-items:center}.multi-search[_ngcontent-%COMP%]   .search-clear-icon[_ngcontent-%COMP%]     .aui-icon{border-radius:50%}.multi-search[_ngcontent-%COMP%]   .search-clear-icon[_ngcontent-%COMP%]     .aui-icon:hover{color:rgb(var(--aui-color-n-10));background-color:rgb(var(--aui-color-n-5))!important}.multi-search[_ngcontent-%COMP%]   .search-suffix[_ngcontent-%COMP%]{display:flex;text-align:center}.multi-search[_ngcontent-%COMP%]   .search-suffix[_ngcontent-%COMP%]   .suffix-wrapper[_ngcontent-%COMP%]{margin-top:4px;margin-bottom:4px;height:calc(100% - 8px);border-left:solid 1px rgb(var(--aui-color-n-7));min-width:30px;display:flex;align-items:center;justify-content:center}.multi-search[_ngcontent-%COMP%]   .search-suffix[_ngcontent-%COMP%]   .suffix-wrapper[_ngcontent-%COMP%]   aui-icon[_ngcontent-%COMP%]:hover{color:rgb(var(--aui-color-blue))}.search-focus[_ngcontent-%COMP%]{border-color:rgb(var(--aui-color-primary));box-shadow:0 0 0 2px rgba(var(--aui-color-primary),.16)}"], changeDetection: 0 }); }
+}
+__decorate([
+    ObservableInput(),
+    __metadata("design:type", Observable)
+], MultiSearchComponent.prototype, "conditions$", void 0);
+__decorate([
+    ObservableInput(),
+    __metadata("design:type", Observable)
+], MultiSearchComponent.prototype, "conditionConfig$", void 0);
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(MultiSearchComponent, [{
+        type: Component,
+        args: [{ selector: 'acl-multi-search', standalone: true, changeDetection: ChangeDetectionStrategy.OnPush, imports: [
+                    NgClass,
+                    AsyncPipe,
+                    TagComponent,
+                    PurePipe,
+                    MultiSearchActionInputComponent,
+                    MultiSearchTagsComponent,
+                    NgFor,
+                    NgIf,
+                    InputComponent,
+                    FormsModule,
+                    IconComponent,
+                ], template: "<div\n  class=\"aui-input multi-search\"\n  #multiSearch\n  [ngClass]=\"{\n    'search-focus': focus$$ | async\n  }\"\n>\n  <!-- \u5DF2\u9009\u62E9\u7C7B\u76EEtags -->\n  <acl-multi-search-tags\n    #tagsRef\n    [ngClass]=\"{\n      'tags-width-with-delete': $any(existingConditions$ | async)?.length,\n      'tags-width': !($any(existingConditions$ | async)?.length),\n    }\"\n    [placeholder]=\"placeholder\"\n    [conditionCreatable]=\"conditionCreatable\"\n    [existingConditions]=\"existingConditions\"\n    [conditionConfig]=\"conditionConfig\"\n    (removeCondition)=\"removeCondition($event)\"\n    (setConditionEditing)=\"setConditionEditing($event)\"\n    (setConditionDeleting)=\"setConditionDeleting($event)\"\n    (search)=\"doSearch()\"\n    (completed)=\"complete($event)\"\n  >\n    <!-- \u672B\u5C3E\u8F93\u5165\u6846 -->\n    <acl-multi-search-action-input\n      #inputRef\n      class=\"input-wrapper\"\n      [isEditing]=\"true\"\n      [hidden]=\"addedInputShouldHidden$ | async\"\n      [placeholder]=\"placeholder\"\n      [conditionCreatable]=\"conditionCreatable\"\n      [conditionConfig]=\"conditionConfig\"\n      [existingConditions]=\"existingConditions$ | async\"\n      [(ngModel)]=\"addedCondition\"\n      (completed)=\"complete($event)\"\n      (delete)=\"setConditionDeleting()\"\n      (search)=\"doSearch()\"\n    ></acl-multi-search-action-input>\n  </acl-multi-search-tags>\n\n  <div class=\"search-suffix\">\n    <div\n      *ngIf=\"$any(existingConditions$ | async)?.length\"\n      class=\"search-clear\"\n    >\n      <aui-icon\n        class=\"tw-text-n-4 tw-cursor-pointer\"\n        [ngClass]=\"CLEAR_ICON_CLASS\"\n        icon=\"xmark_small\"\n        size=\"14\"\n        (click)=\"clearConditions(); doSearch(); $event.stopPropagation()\"\n      ></aui-icon>\n    </div>\n    <div class=\"search-suffix\">\n      <div class=\"suffix-wrapper\">\n        <aui-icon\n          class=\"tw-text-n-4 tw-cursor-pointer\"\n          [ngClass]=\"SEARCH_ICON_CLASS\"\n          icon=\"magnifier\"\n          (click)=\"doSearch(); $event.stopPropagation()\"\n        ></aui-icon>\n      </div>\n    </div>\n  </div>\n</div>\n", styles: [":host{min-width:0}.multi-search{min-width:240px;height:max-content;display:flex;align-items:stretch;padding:0;overflow-y:auto}.multi-search .tags-width{width:calc(100% - 30px)}.multi-search .tags-width-with-delete{width:calc(100% - 48px)}.multi-search .search-clear{width:18px;display:flex;align-items:center}.multi-search .search-clear-icon ::ng-deep .aui-icon{border-radius:50%}.multi-search .search-clear-icon ::ng-deep .aui-icon:hover{color:rgb(var(--aui-color-n-10));background-color:rgb(var(--aui-color-n-5))!important}.multi-search .search-suffix{display:flex;text-align:center}.multi-search .search-suffix .suffix-wrapper{margin-top:4px;margin-bottom:4px;height:calc(100% - 8px);border-left:solid 1px rgb(var(--aui-color-n-7));min-width:30px;display:flex;align-items:center;justify-content:center}.multi-search .search-suffix .suffix-wrapper aui-icon:hover{color:rgb(var(--aui-color-blue))}.search-focus{border-color:rgb(var(--aui-color-primary));box-shadow:0 0 0 2px rgba(var(--aui-color-primary),.16)}\n"] }]
+    }], function () { return [{ type: i0.ChangeDetectorRef }]; }, { placeholder: [{
+            type: Input
+        }], conditionCreatable: [{
+            type: Input
+        }], conditions: [{
+            type: Input
+        }], conditions$: [], conditionConfig: [{
+            type: Input
+        }], conditionConfig$: [], search: [{
+            type: Output
+        }], conditionsChange: [{
+            type: Output
+        }], normalInputComponent: [{
+            type: ViewChild,
+            args: ['inputRef']
+        }], tagsComponent: [{
+            type: ViewChild,
+            args: ['tagsRef']
+        }], multiSearchRef: [{
+            type: ViewChild,
+            args: ['multiSearch', { static: true }]
+        }] }); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"component.js","sourceRoot":"","sources":["../../../../../../libs/common/src/multi-search/form/component.ts","../../../../../../libs/common/src/multi-search/form/template.html"],"names":[],"mappings":"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","sourcesContent":["import { IconComponent, InputComponent, TagComponent } from '@alauda/ui';\nimport { AsyncPipe, NgClass, NgFor, NgIf } from '@angular/common';\nimport {\n  ChangeDetectionStrategy,\n  ChangeDetectorRef,\n  Component,\n  ElementRef,\n  EventEmitter,\n  Input,\n  OnDestroy,\n  Output,\n  ViewChild,\n} from '@angular/core';\nimport { FormsModule } from '@angular/forms';\nimport { cloneDeep, isEmpty, isEqual, set } from 'lodash-es';\nimport {\n  BehaviorSubject,\n  combineLatest,\n  distinctUntilChanged,\n  fromEvent,\n  map,\n  merge,\n  Observable,\n  scan,\n  Subject,\n  take,\n  takeUntil,\n  tap,\n} from 'rxjs';\n\nimport { ObservableInput, publishRef } from '../../core';\nimport { PurePipe } from '../../scm';\nimport { MultiSearchActionInputComponent } from '../action-input/component';\nimport { MultiSearchTagsComponent } from '../multi-search-tags/component';\nimport {\n  SearchConditionConfig,\n  SearchCondition,\n  SearchConditionModel,\n} from '../types';\n\nexport const DEFAULT_OPERATOR: string = '=';\n\n@Component({\n  selector: 'acl-multi-search',\n  standalone: true,\n  templateUrl: './template.html',\n  styleUrls: ['./styles.scss'],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  imports: [\n    NgClass,\n    AsyncPipe,\n    TagComponent,\n    PurePipe,\n    MultiSearchActionInputComponent,\n    MultiSearchTagsComponent,\n    NgFor,\n    NgIf,\n    InputComponent,\n    FormsModule,\n    IconComponent,\n  ],\n})\nexport class MultiSearchComponent implements OnDestroy {\n  @Input()\n  placeholder: string = '';\n\n  @Input()\n  conditionCreatable: boolean = false;\n\n  // search value\n  @Input()\n  conditions: SearchCondition[];\n\n  @ObservableInput()\n  conditions$!: Observable<SearchCondition[]>;\n\n  // 类目配置\n  @Input()\n  conditionConfig: SearchConditionConfig[];\n\n  @ObservableInput()\n  conditionConfig$!: Observable<SearchConditionConfig[]>;\n\n  // 搜索操作\n  @Output()\n  search = new EventEmitter<SearchCondition[]>();\n\n  // 条件变化\n  @Output()\n  conditionsChange = new EventEmitter<SearchCondition[]>();\n\n  @ViewChild('inputRef')\n  normalInputComponent: MultiSearchActionInputComponent;\n\n  @ViewChild('tagsRef')\n  tagsComponent: MultiSearchTagsComponent;\n\n  @ViewChild('multiSearch', { static: true })\n  multiSearchRef: ElementRef;\n\n  addedCondition: SearchConditionModel;\n\n  // 当前multi-search组件是否focus\n  focus$$ = new BehaviorSubject<boolean>(false);\n\n  destroy$$ = new Subject<void>();\n\n  actionScanner$$ = new Subject<\n    (items: SearchConditionModel[]) => SearchConditionModel[]\n  >();\n\n  existingConditions: SearchConditionModel[] = [];\n  existingConditions$ = merge(\n    combineLatest([this.conditions$, this.conditionConfig$]).pipe(\n      map(([conditions, conditionConfig]) => {\n        const res =\n          conditions?.map(condition => {\n            const exist = this.existingConditions?.find(\n              exist => exist.condition.value === condition.condition,\n            );\n            const config = conditionConfig?.find(\n              config => config.condition.value === condition.condition,\n            );\n\n            // 所继承的数据，若已存在exist，则继承exist；若不存在，则继承config\n            // 此处的继承是为了防止外界conditions数据的变化导致操作状态刷新\n            // 因此，除了conditions数据外的附加数据，都应该继承\n            const inherit = {\n              ...exist,\n              ...config,\n            };\n\n            return isEmpty(inherit)\n              ? ({\n                  condition: { value: condition.condition },\n                  operator: condition.operator,\n                  selectedValues: condition.values?.map(value => ({\n                    value,\n                  })),\n                } as SearchConditionModel)\n              : ({\n                  ...inherit,\n                  operator: condition.operator,\n                  selectedValues: condition.values?.map(value => {\n                    const find = inherit.values?.find(\n                      inheritValue => inheritValue.value === value,\n                    );\n                    return find\n                      ? { ...find }\n                      : {\n                          value,\n                        };\n                  }),\n                } as SearchConditionModel);\n          }) || [];\n        return (_: SearchConditionModel[]) => res;\n      }),\n    ),\n    this.actionScanner$$,\n  ).pipe(\n    scan((acc, cur) => cur(acc), [] as SearchConditionModel[]),\n    tap(existingConditions => {\n      this.existingConditions = existingConditions;\n    }),\n    publishRef(),\n  );\n\n  noEditingCondition: boolean = true;\n  noEditingCondition$ = this.existingConditions$.pipe(\n    map(existingConditions =>\n      existingConditions?.every(condition => !condition.isEditing),\n    ),\n    tap(noEditingCondition => (this.noEditingCondition = noEditingCondition)),\n    publishRef(),\n  );\n\n  noDeletingCondition: boolean = true;\n  noDeletingCondition$ = this.existingConditions$.pipe(\n    map(existingConditions =>\n      existingConditions?.every(condition => !condition.isDeleting),\n    ),\n    tap(\n      noDeletingCondition => (this.noDeletingCondition = noDeletingCondition),\n    ),\n    publishRef(),\n  );\n\n  addedInputShouldHidden$ = combineLatest([\n    this.noEditingCondition$,\n    this.noDeletingCondition$,\n    this.existingConditions$,\n  ]).pipe(\n    map(([noEditingCondition, noDeletingCondition, existingConditions]) => {\n      return (\n        (!noEditingCondition || !noDeletingCondition) &&\n        existingConditions.length !== 0\n      );\n    }),\n    publishRef(),\n  );\n\n  get inputComponent() {\n    return this.noDeletingCondition && this.noEditingCondition\n      ? this.normalInputComponent\n      : this.tagsComponent?.inputComponent;\n  }\n\n  CLEAR_ICON_CLASS = 'search-clear-icon';\n\n  SEARCH_ICON_CLASS = 'search-icon';\n\n  constructor(protected readonly cdr: ChangeDetectorRef) {\n    this.existingConditions$\n      .pipe(\n        takeUntil(this.destroy$$),\n        distinctUntilChanged((a, b) => a?.length === b?.length),\n      )\n      .subscribe(existingConditions => {\n        this.conditionsChange.emit(this.getConditionModel(existingConditions));\n      });\n    // 此处的click事件监听使用了捕获而非冒泡，是为了让事件触发的时机先于tag.click\n    // 若tag.click先触发，会导致element.contains()判断出错\n    fromEvent(document.body, 'click', { capture: true })\n      .pipe(takeUntil(this.destroy$$))\n      .subscribe(event => {\n        const target = event.target as Element;\n\n        if (this.isSearchBtn(target)) {\n          this.manualComplete(false, true);\n          this.inputComponent.toolTipHide();\n          return;\n        }\n\n        // eslint-disable-next-line @typescript-eslint/no-unsafe-call\n        if (this.multiSearchRef?.nativeElement?.contains(target)) {\n          // 当点击区域为multi-search组件，自动聚焦\n\n          // 对于操作按钮，只做hidden toolTip\n          if (this.notActionElement(target)) {\n            if (document.activeElement !== this.inputComponent?.inputElement) {\n              const isFocus = this.focus$$.value;\n              this.manualFocus(isFocus);\n            }\n            this.inputComponent.toolTipShow();\n          } else {\n            this.manualFocus(true);\n\n            // this.inputComponent.toolTipHide();\n          }\n          // 当点击区域为非tooltip的其他区域时，自动收缩\n        } else if (this.notTooltipContent(target)) {\n          this.manualBlur();\n        }\n      });\n  }\n\n  private isSearchBtn(element: Element) {\n    return this.checkElement(element, element =>\n      element?.className?.includes?.(this.SEARCH_ICON_CLASS),\n    );\n  }\n\n  private notActionElement(element: Element) {\n    return !this.checkElement(\n      element,\n      element =>\n        element?.className?.includes?.(this.CLEAR_ICON_CLASS) ||\n        element?.className?.includes?.(this.SEARCH_ICON_CLASS) ||\n        element?.className?.includes?.('aui-tag__close'),\n    );\n  }\n\n  private notTooltipContent(element: Element) {\n    return !this.checkElement(\n      element,\n      element => element.tagName === 'AUI-TOOLTIP',\n    );\n  }\n\n  private checkElement(element: Element, fn: (e: Element) => boolean) {\n    while (element && !fn(element)) {\n      element = element.parentElement;\n    }\n\n    return !!element;\n  }\n\n  private manualComplete(\n    toContinue: boolean = false,\n    manualFocus: boolean = false,\n  ) {\n    this.inputComponent?.ifComplete(toContinue, manualFocus);\n  }\n\n  manualFocus(silence?: boolean) {\n    this.setFocus(true);\n    this.inputComponent?.manualFocus(silence);\n  }\n\n  setFocus(focus: boolean) {\n    this.focus$$.next(focus);\n  }\n\n  manualBlur() {\n    this.setFocus(false);\n    this.inputComponent?.manualBlur();\n  }\n\n  // 搜索操作\n  doSearch() {\n    this.existingConditions$\n      .pipe(take(1), takeUntil(this.destroy$$))\n      .subscribe(exists => {\n        this.search.emit(\n          this.getConditionModel(\n            exists?.filter(exist => !this.conditionInAction(exist)),\n          ),\n        );\n      });\n  }\n\n  // 清除所有已选条件\n  clearConditions() {\n    this.addedCondition = null;\n    this.cdr.markForCheck();\n    this.actionScanner$$.next((_: SearchConditionModel[]) => []);\n  }\n\n  // 移除当前条件\n  removeCondition(condition: SearchConditionModel) {\n    const remove = (existingConditions: SearchConditionModel[]) => {\n      const idx = existingConditions.findIndex(\n        con => con.condition.value === condition.condition.value,\n      );\n      existingConditions.splice(idx, 1);\n      return [...existingConditions];\n    };\n    this.actionScanner$$.next(remove);\n  }\n\n  // 更新条件\n  updateCondition(condition: SearchConditionModel, index: number) {\n    const _update = (existingConditions: SearchConditionModel[]) => {\n      if (condition) {\n        existingConditions.splice(index, 1, condition);\n      } else {\n        existingConditions.splice(index, 1);\n      }\n      return [...existingConditions];\n    };\n\n    this.actionScanner$$.next(_update);\n  }\n\n  // 添加condition\n  addCondition(activeCondition: SearchConditionModel) {\n    const _add = (existingConditions: SearchConditionModel[]) => {\n      existingConditions.push(activeCondition);\n      return [...existingConditions];\n    };\n\n    this.actionScanner$$.next(_add);\n  }\n\n  // 设置condition的状态为编辑态\n  setConditionEditing(condition: SearchConditionModel) {\n    if (this.isGrammarCustomCondition(condition)) return;\n    const _update = (existingConditions: SearchConditionModel[]) => {\n      if (!existingConditions) return;\n      const idx = existingConditions.findIndex(\n        con => con.condition.value === condition.condition.value,\n      );\n\n      const conditionsExceptCur = [\n        ...(existingConditions.slice(0, idx) || []),\n        ...(existingConditions.slice(idx + 1) || []),\n      ];\n\n      const alreadyHaveAction = conditionsExceptCur.some(con =>\n        this.conditionInAction(con),\n      );\n      // 当已经存在操作中的condition时，会继续维护之前操作，中止新的操作行为\n      // 上述处理逻辑主要是为了避免操作到一半（比如未选择operator、未选择condition时）就切换至另一个condition操作，此时该未完成的操作应该如何处理，暂未给定。\n      if (alreadyHaveAction || this.addedCondition) return existingConditions;\n\n      const find = existingConditions[idx];\n      // 将当前所操作condition的状态重置为editing\n      find.isDeleting = false;\n      find.isEditing = true;\n\n      find.actionModel = cloneDeep(find);\n      return [...existingConditions];\n    };\n\n    this.actionScanner$$.next(_update);\n  }\n\n  // 设置condition的状态为删除态\n  setConditionDeleting(index?: number) {\n    const _delete = (existingConditions: SearchConditionModel[]) => {\n      const condition = Number.isInteger(index)\n        ? existingConditions[index]\n        : existingConditions.at(-1);\n\n      if (condition) {\n        set(condition, 'isDeleting', true);\n        condition.actionModel = cloneDeep(condition);\n      }\n\n      return [...existingConditions];\n    };\n    this.actionScanner$$.next(_delete);\n  }\n\n  complete({\n    activeCondition,\n    toContinue,\n    manualFocus,\n    index,\n  }: {\n    activeCondition: SearchConditionModel;\n    toContinue?: boolean;\n    manualFocus?: boolean;\n    index?: number;\n  }) {\n    if (activeCondition) {\n      activeCondition.isEditing = false;\n      activeCondition.isDeleting = false;\n    }\n\n    if (Number.isInteger(index)) {\n      this.updateCondition(activeCondition, index);\n    } else if (activeCondition) {\n      this.addCondition(activeCondition);\n    }\n    // 自动聚焦\n    if (manualFocus) {\n      this.manualFocus(!toContinue);\n    }\n  }\n\n  private isGrammarCustomCondition(condition: SearchConditionModel): boolean {\n    const inConfig = this.conditionConfig.some(config =>\n      isEqual(condition.condition, config.condition),\n    );\n    // 如果当前condition不在config中，且operator不为默认值，则代表当前condition是用户通过语法自定义的，此时不允许通过UI修改\n    // 考虑到未来会允许用户输入创建condition，此时是允许用户通过UI再次修改的。此类情况的特性：!inConfig && operator === DEFAULT_OPERATOR\n    return !inConfig && condition.operator !== DEFAULT_OPERATOR;\n  }\n\n  private getConditionModel(conditions: SearchConditionModel[]) {\n    return conditions?.map(condition => ({\n      condition: condition.condition.value,\n      operator: condition.operator,\n      values: condition.selectedValues?.map(value => value.value) || [],\n    }));\n  }\n\n  conditionInAction(condition: SearchConditionModel) {\n    return condition.isEditing || condition.isDeleting;\n  }\n\n  ngOnDestroy(): void {\n    this.destroy$$.next();\n  }\n}\n","<div\n  class=\"aui-input multi-search\"\n  #multiSearch\n  [ngClass]=\"{\n    'search-focus': focus$$ | async\n  }\"\n>\n  <!-- 已选择类目tags -->\n  <acl-multi-search-tags\n    #tagsRef\n    [ngClass]=\"{\n      'tags-width-with-delete': $any(existingConditions$ | async)?.length,\n      'tags-width': !($any(existingConditions$ | async)?.length),\n    }\"\n    [placeholder]=\"placeholder\"\n    [conditionCreatable]=\"conditionCreatable\"\n    [existingConditions]=\"existingConditions\"\n    [conditionConfig]=\"conditionConfig\"\n    (removeCondition)=\"removeCondition($event)\"\n    (setConditionEditing)=\"setConditionEditing($event)\"\n    (setConditionDeleting)=\"setConditionDeleting($event)\"\n    (search)=\"doSearch()\"\n    (completed)=\"complete($event)\"\n  >\n    <!-- 末尾输入框 -->\n    <acl-multi-search-action-input\n      #inputRef\n      class=\"input-wrapper\"\n      [isEditing]=\"true\"\n      [hidden]=\"addedInputShouldHidden$ | async\"\n      [placeholder]=\"placeholder\"\n      [conditionCreatable]=\"conditionCreatable\"\n      [conditionConfig]=\"conditionConfig\"\n      [existingConditions]=\"existingConditions$ | async\"\n      [(ngModel)]=\"addedCondition\"\n      (completed)=\"complete($event)\"\n      (delete)=\"setConditionDeleting()\"\n      (search)=\"doSearch()\"\n    ></acl-multi-search-action-input>\n  </acl-multi-search-tags>\n\n  <div class=\"search-suffix\">\n    <div\n      *ngIf=\"$any(existingConditions$ | async)?.length\"\n      class=\"search-clear\"\n    >\n      <aui-icon\n        class=\"tw-text-n-4 tw-cursor-pointer\"\n        [ngClass]=\"CLEAR_ICON_CLASS\"\n        icon=\"xmark_small\"\n        size=\"14\"\n        (click)=\"clearConditions(); doSearch(); $event.stopPropagation()\"\n      ></aui-icon>\n    </div>\n    <div class=\"search-suffix\">\n      <div class=\"suffix-wrapper\">\n        <aui-icon\n          class=\"tw-text-n-4 tw-cursor-pointer\"\n          [ngClass]=\"SEARCH_ICON_CLASS\"\n          icon=\"magnifier\"\n          (click)=\"doSearch(); $event.stopPropagation()\"\n        ></aui-icon>\n      </div>\n    </div>\n  </div>\n</div>\n"]}

package/esm2022/multi-search/index.mjs

@@ -0,0 +1,5 @@
+export * from './utils';
+export * from './types';
+export * from './form/component';
+export * from './action-input/component';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9saWJzL2NvbW1vbi9zcmMvbXVsdGktc2VhcmNoL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsU0FBUyxDQUFDO0FBQ3hCLGNBQWMsU0FBUyxDQUFDO0FBQ3hCLGNBQWMsa0JBQWtCLENBQUM7QUFDakMsY0FBYywwQkFBMEIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vdXRpbHMnO1xuZXhwb3J0ICogZnJvbSAnLi90eXBlcyc7XG5leHBvcnQgKiBmcm9tICcuL2Zvcm0vY29tcG9uZW50JztcbmV4cG9ydCAqIGZyb20gJy4vYWN0aW9uLWlucHV0L2NvbXBvbmVudCc7XG4iXX0=

package/esm2022/multi-search/multi-search-tags/component.mjs

@@ -0,0 +1,129 @@
+import { TagModule } from '@alauda/ui';
+import { NgClass, NgFor, NgIf } from '@angular/common';
+import { ChangeDetectionStrategy, Component, EventEmitter, Input, Output, ViewChild, } from '@angular/core';
+import { FormsModule } from '@angular/forms';
+import { PurePipeModule } from '../../scm';
+import { MultiSearchActionInputComponent } from '../action-input/component';
+import * as i0 from "@angular/core";
+import * as i1 from "@alauda/ui";
+import * as i2 from "../../scm/pure-pipe/pure.pipe";
+import * as i3 from "@angular/forms";
+const _c0 = ["inputRef"];
+function MultiSearchTagsComponent_ng_container_1_aui_tag_1_Template(rf, ctx) { if (rf & 1) {
+    const _r8 = i0.ɵɵgetCurrentView();
+    i0.ɵɵelementStart(0, "aui-tag", 4);
+    i0.ɵɵlistener("close", function MultiSearchTagsComponent_ng_container_1_aui_tag_1_Template_aui_tag_close_0_listener() { i0.ɵɵrestoreView(_r8); const condition_r1 = i0.ɵɵnextContext().$implicit; const ctx_r6 = i0.ɵɵnextContext(); ctx_r6.removeCondition.emit(condition_r1); return i0.ɵɵresetView(ctx_r6.search.emit()); })("click", function MultiSearchTagsComponent_ng_container_1_aui_tag_1_Template_aui_tag_click_0_listener() { i0.ɵɵrestoreView(_r8); const condition_r1 = i0.ɵɵnextContext().$implicit; const ctx_r9 = i0.ɵɵnextContext(); return i0.ɵɵresetView(ctx_r9.setConditionEditing.emit(condition_r1)); });
+    i0.ɵɵelementStart(1, "span", 5);
+    i0.ɵɵpipe(2, "pure");
+    i0.ɵɵpipe(3, "pure");
+    i0.ɵɵtext(4);
+    i0.ɵɵpipe(5, "pure");
+    i0.ɵɵpipe(6, "pure");
+    i0.ɵɵelementEnd()();
+} if (rf & 2) {
+    const condition_r1 = i0.ɵɵnextContext().$implicit;
+    const ctx_r3 = i0.ɵɵnextContext();
+    i0.ɵɵproperty("ngClass", condition_r1.tagClass)("type", condition_r1.tagType || "info")("border", true)("closeable", true);
+    i0.ɵɵadvance(1);
+    i0.ɵɵproperty("title", i0.ɵɵpipeBind2(2, 8, condition_r1, ctx_r3.getConditionLabel) + " " + condition_r1.operator + " " + i0.ɵɵpipeBind2(3, 11, condition_r1, ctx_r3.getValueContent));
+    i0.ɵɵadvance(3);
+    i0.ɵɵtextInterpolate3(" ", i0.ɵɵpipeBind2(5, 14, condition_r1, ctx_r3.getConditionLabel), " ", condition_r1.operator, " ", i0.ɵɵpipeBind2(6, 17, condition_r1, ctx_r3.getValueContent), " ");
+} }
+const _c1 = function (a0) { return { "deleting-input": a0 }; };
+function MultiSearchTagsComponent_ng_container_1_ng_template_2_Template(rf, ctx) { if (rf & 1) {
+    const _r15 = i0.ɵɵgetCurrentView();
+    i0.ɵɵelementStart(0, "acl-multi-search-action-input", 6, 7);
+    i0.ɵɵlistener("ngModelChange", function MultiSearchTagsComponent_ng_container_1_ng_template_2_Template_acl_multi_search_action_input_ngModelChange_0_listener($event) { i0.ɵɵrestoreView(_r15); const condition_r1 = i0.ɵɵnextContext().$implicit; return i0.ɵɵresetView(condition_r1.actionModel = $event); })("completed", function MultiSearchTagsComponent_ng_container_1_ng_template_2_Template_acl_multi_search_action_input_completed_0_listener($event) { i0.ɵɵrestoreView(_r15); const index_r2 = i0.ɵɵnextContext().index; const ctx_r16 = i0.ɵɵnextContext(); return i0.ɵɵresetView(ctx_r16.completed.emit({ activeCondition: $event.activeCondition, toContinue: $event.toContinue, manualFocus: $event.manualFocus, index: index_r2 })); })("delete", function MultiSearchTagsComponent_ng_container_1_ng_template_2_Template_acl_multi_search_action_input_delete_0_listener() { i0.ɵɵrestoreView(_r15); const index_r2 = i0.ɵɵnextContext().index; const ctx_r18 = i0.ɵɵnextContext(); return i0.ɵɵresetView(ctx_r18.setConditionDeleting.emit(index_r2 - 1)); })("editing", function MultiSearchTagsComponent_ng_container_1_ng_template_2_Template_acl_multi_search_action_input_editing_0_listener() { i0.ɵɵrestoreView(_r15); const condition_r1 = i0.ɵɵnextContext().$implicit; const ctx_r20 = i0.ɵɵnextContext(); return i0.ɵɵresetView(ctx_r20.setConditionEditing.emit(condition_r1)); })("search", function MultiSearchTagsComponent_ng_container_1_ng_template_2_Template_acl_multi_search_action_input_search_0_listener() { i0.ɵɵrestoreView(_r15); const ctx_r22 = i0.ɵɵnextContext(2); return i0.ɵɵresetView(ctx_r22.search.emit()); });
+    i0.ɵɵelementEnd();
+} if (rf & 2) {
+    const condition_r1 = i0.ɵɵnextContext().$implicit;
+    const ctx_r5 = i0.ɵɵnextContext();
+    i0.ɵɵproperty("ngClass", i0.ɵɵpureFunction1(7, _c1, condition_r1.isDeleting))("isEditing", condition_r1.isEditing)("conditionCreatable", ctx_r5.conditionCreatable)("placeholder", ctx_r5.placeholder)("conditionConfig", ctx_r5.conditionConfig)("existingConditions", ctx_r5.existingConditions)("ngModel", condition_r1.actionModel);
+} }
+function MultiSearchTagsComponent_ng_container_1_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelementContainerStart(0);
+    i0.ɵɵtemplate(1, MultiSearchTagsComponent_ng_container_1_aui_tag_1_Template, 7, 20, "aui-tag", 2);
+    i0.ɵɵtemplate(2, MultiSearchTagsComponent_ng_container_1_ng_template_2_Template, 2, 9, "ng-template", null, 3, i0.ɵɵtemplateRefExtractor);
+    i0.ɵɵelementContainerEnd();
+} if (rf & 2) {
+    const condition_r1 = ctx.$implicit;
+    const _r4 = i0.ɵɵreference(3);
+    const ctx_r0 = i0.ɵɵnextContext();
+    i0.ɵɵadvance(1);
+    i0.ɵɵproperty("ngIf", !ctx_r0.conditionInAction(condition_r1))("ngIfElse", _r4);
+} }
+const _c2 = ["*"];
+export class MultiSearchTagsComponent {
+    constructor() {
+        this.removeCondition = new EventEmitter();
+        this.setConditionEditing = new EventEmitter();
+        this.setConditionDeleting = new EventEmitter();
+        this.search = new EventEmitter();
+        this.completed = new EventEmitter();
+    }
+    conditionInAction(condition) {
+        return condition.isEditing || condition.isDeleting;
+    }
+    getConditionLabel(condition) {
+        return condition?.condition?.label ?? condition?.condition?.value;
+    }
+    getValueContent(condition) {
+        return condition?.selectedValues
+            ?.map(value => value.label || value.value)
+            ?.join(condition.separator ?? '|');
+    }
+    static { this.ɵfac = function MultiSearchTagsComponent_Factory(t) { return new (t || MultiSearchTagsComponent)(); }; }
+    static { this.ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: MultiSearchTagsComponent, selectors: [["acl-multi-search-tags"]], viewQuery: function MultiSearchTagsComponent_Query(rf, ctx) { if (rf & 1) {
+            i0.ɵɵviewQuery(_c0, 5);
+        } if (rf & 2) {
+            let _t;
+            i0.ɵɵqueryRefresh(_t = i0.ɵɵloadQuery()) && (ctx.inputComponent = _t.first);
+        } }, inputs: { placeholder: "placeholder", conditionCreatable: "conditionCreatable", conditionConfig: "conditionConfig", existingConditions: "existingConditions" }, outputs: { removeCondition: "removeCondition", setConditionEditing: "setConditionEditing", setConditionDeleting: "setConditionDeleting", search: "search", completed: "completed" }, standalone: true, features: [i0.ɵɵStandaloneFeature], ngContentSelectors: _c2, decls: 3, vars: 1, consts: [[1, "search-content"], [4, "ngFor", "ngForOf"], ["class", "tw-ml-6 tw-h-[22px] tw-mb-4", "size", "mini", 3, "ngClass", "type", "border", "closeable", "close", "click", 4, "ngIf", "ngIfElse"], ["inAction", ""], ["size", "mini", 1, "tw-ml-6", "tw-h-[22px]", "tw-mb-4", 3, "ngClass", "type", "border", "closeable", "close", "click"], [3, "title"], [1, "input-wrapper", 3, "ngClass", "isEditing", "conditionCreatable", "placeholder", "conditionConfig", "existingConditions", "ngModel", "ngModelChange", "completed", "delete", "editing", "search"], ["inputRef", ""]], template: function MultiSearchTagsComponent_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵelementStart(0, "div", 0);
+            i0.ɵɵtemplate(1, MultiSearchTagsComponent_ng_container_1_Template, 4, 2, "ng-container", 1);
+            i0.ɵɵprojection(2);
+            i0.ɵɵelementEnd();
+        } if (rf & 2) {
+            i0.ɵɵadvance(1);
+            i0.ɵɵproperty("ngForOf", ctx.existingConditions);
+        } }, dependencies: [NgIf,
+            NgFor,
+            TagModule, i1.TagComponent, NgClass,
+            PurePipeModule, i2.PurePipe, MultiSearchActionInputComponent,
+            FormsModule, i3.NgControlStatus, i3.NgModel], styles: ["[_nghost-%COMP%]{display:block}[_nghost-%COMP%]   .search-content[_ngcontent-%COMP%]{width:100%;min-height:30px;max-height:160px;padding-top:4px;flex:1;display:flex;flex-wrap:wrap;align-items:center}[_nghost-%COMP%]   .search-content[_ngcontent-%COMP%]     aui-tag{max-width:calc(100% - 8px)}[_nghost-%COMP%]   .search-content[_ngcontent-%COMP%]     .aui-tag{margin-left:0;max-width:100%}[_nghost-%COMP%]   .search-content[_ngcontent-%COMP%]     .input-wrapper{padding-bottom:4px;max-width:100%;width:max-content;min-width:180px;white-space:nowrap;word-break:break-all;overflow:hidden;text-overflow:ellipsis;flex-grow:1;flex-shrink:0}"], changeDetection: 0 }); }
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(MultiSearchTagsComponent, [{
+        type: Component,
+        args: [{ selector: 'acl-multi-search-tags', standalone: true, changeDetection: ChangeDetectionStrategy.OnPush, imports: [
+                    NgIf,
+                    NgFor,
+                    TagModule,
+                    NgClass,
+                    PurePipeModule,
+                    MultiSearchActionInputComponent,
+                    FormsModule,
+                ], template: "<div class=\"search-content\">\n  <ng-container *ngFor=\"let condition of existingConditions; let index = index\">\n    <aui-tag\n      *ngIf=\"!conditionInAction(condition); else inAction\"\n      class=\"tw-ml-6 tw-h-[22px] tw-mb-4\"\n      [ngClass]=\"condition.tagClass\"\n      [type]=\"condition.tagType || 'info'\"\n      [border]=\"true\"\n      [closeable]=\"true\"\n      (close)=\"removeCondition.emit(condition); search.emit()\"\n      (click)=\"setConditionEditing.emit(condition)\"\n      size=\"mini\"\n    >\n      <span\n        [title]=\"\n          (condition | pure: getConditionLabel) +\n          ' ' +\n          condition.operator +\n          ' ' +\n          (condition | pure: getValueContent)\n        \"\n      >\n        {{ condition | pure: getConditionLabel }}\n        {{ condition.operator }}\n        {{ condition | pure: getValueContent }}\n      </span>\n    </aui-tag>\n\n    <ng-template #inAction>\n      <acl-multi-search-action-input\n        #inputRef\n        class=\"input-wrapper\"\n        [ngClass]=\"{ 'deleting-input': condition.isDeleting }\"\n        [isEditing]=\"condition.isEditing\"\n        [conditionCreatable]=\"conditionCreatable\"\n        [placeholder]=\"placeholder\"\n        [conditionConfig]=\"conditionConfig\"\n        [existingConditions]=\"existingConditions\"\n        [(ngModel)]=\"condition.actionModel\"\n        (completed)=\"\n          completed.emit({\n            activeCondition: $event.activeCondition,\n            toContinue: $event.toContinue,\n            manualFocus: $event.manualFocus,\n            index: index\n          })\n        \"\n        (delete)=\"setConditionDeleting.emit(index - 1)\"\n        (editing)=\"setConditionEditing.emit(condition)\"\n        (search)=\"search.emit()\"\n      ></acl-multi-search-action-input>\n    </ng-template>\n  </ng-container>\n  <ng-content></ng-content>\n</div>\n", styles: [":host{display:block}:host .search-content{width:100%;min-height:30px;max-height:160px;padding-top:4px;flex:1;display:flex;flex-wrap:wrap;align-items:center}:host .search-content ::ng-deep aui-tag{max-width:calc(100% - 8px)}:host .search-content ::ng-deep .aui-tag{margin-left:0;max-width:100%}:host .search-content ::ng-deep .input-wrapper{padding-bottom:4px;max-width:100%;width:max-content;min-width:180px;white-space:nowrap;word-break:break-all;overflow:hidden;text-overflow:ellipsis;flex-grow:1;flex-shrink:0}\n"] }]
+    }], null, { placeholder: [{
+            type: Input
+        }], conditionCreatable: [{
+            type: Input
+        }], conditionConfig: [{
+            type: Input
+        }], existingConditions: [{
+            type: Input
+        }], removeCondition: [{
+            type: Output
+        }], setConditionEditing: [{
+            type: Output
+        }], setConditionDeleting: [{
+            type: Output
+        }], search: [{
+            type: Output
+        }], completed: [{
+            type: Output
+        }], inputComponent: [{
+            type: ViewChild,
+            args: ['inputRef']
+        }] }); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"component.js","sourceRoot":"","sources":["../../../../../../libs/common/src/multi-search/multi-search-tags/component.ts","../../../../../../libs/common/src/multi-search/multi-search-tags/template.html"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AACvC,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAC;AACvD,OAAO,EACL,uBAAuB,EACvB,SAAS,EACT,YAAY,EACZ,KAAK,EACL,MAAM,EACN,SAAS,GACV,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAE7C,OAAO,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAC3C,OAAO,EAAE,+BAA+B,EAAE,MAAM,2BAA2B,CAAC;;;;;;;;ICXxE,kCAUC;IAHC,qOAAS,yCAA+B,SAAE,eAAA,oBAAa,CAAA,IAAC,+NAC/C,eAAA,6CAAmC,CAAA,IADY;IAIxD,+BAQC;;;IACC,YAGF;;;IAAA,iBAAO,EAAA;;;;IApBP,+CAA8B,wCAAA,gBAAA,mBAAA;IAS5B,eAMC;IAND,sLAMC;IAED,eAGF;IAHE,4LAGF;;;;;IAIA,2DAqBC;IAZC,0PAAa,iDACf,IADqC,iQAEtB,eAAA,oJAOrB,CAAA,IAT2C,qPASzB,eAAA,6CAAkC,CAAC,CAAC,CAAA,IATX,+PAUxB,eAAA,8CAAmC,CAAA,IAVX,2MAWzB,eAAA,qBAAa,CAAA,IAXY;IAYpC,iBAAgC;;;;IAlB/B,6EAAsD,qCAAA,iDAAA,mCAAA,2CAAA,iDAAA,qCAAA;;;IA/B5D,6BAA8E;IAC5E,iGAwBU;IAEV,yIAuBc;IAChB,0BAAe;;;;;IAjDV,eAAqC;IAArC,8DAAqC,iBAAA;;;AD6B5C,MAAM,OAAO,wBAAwB;IAhBrC;QA8BE,oBAAe,GAAG,IAAI,YAAY,EAAwB,CAAC;QAG3D,wBAAmB,GAAG,IAAI,YAAY,EAAwB,CAAC;QAG/D,yBAAoB,GAAG,IAAI,YAAY,EAAU,CAAC;QAGlD,WAAM,GAAG,IAAI,YAAY,EAAQ,CAAC;QAGlC,cAAS,GAAG,IAAI,YAAY,EAKxB,CAAC;KAkBN;IAbC,iBAAiB,CAAC,SAA+B;QAC/C,OAAO,SAAS,CAAC,SAAS,IAAI,SAAS,CAAC,UAAU,CAAC;IACrD,CAAC;IAED,iBAAiB,CAAC,SAA+B;QAC/C,OAAO,SAAS,EAAE,SAAS,EAAE,KAAK,IAAI,SAAS,EAAE,SAAS,EAAE,KAAK,CAAC;IACpE,CAAC;IAED,eAAe,CAAC,SAA+B;QAC7C,OAAO,SAAS,EAAE,cAAc;YAC9B,EAAE,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC,KAAK,CAAC,KAAK,IAAI,KAAK,CAAC,KAAK,CAAC;YAC1C,EAAE,IAAI,CAAC,SAAS,CAAC,SAAS,IAAI,GAAG,CAAC,CAAC;IACvC,CAAC;yFAhDU,wBAAwB;oEAAxB,wBAAwB;;;;;;;YChCrC,8BAA4B;YAC1B,2FAmDe;YACf,kBAAyB;YAC3B,iBAAM;;YArDgC,eAAuB;YAAvB,gDAAuB;4BDsBzD,IAAI;YACJ,KAAK;YACL,SAAS,mBACT,OAAO;YACP,cAAc,eACd,+BAA+B;YAC/B,WAAW;;uFAGF,wBAAwB;cAhBpC,SAAS;2BACE,uBAAuB,cACrB,IAAI,mBAGC,uBAAuB,CAAC,MAAM,WACtC;oBACP,IAAI;oBACJ,KAAK;oBACL,SAAS;oBACT,OAAO;oBACP,cAAc;oBACd,+BAA+B;oBAC/B,WAAW;iBACZ;gBAID,WAAW;kBADV,KAAK;YAIN,kBAAkB;kBADjB,KAAK;YAIN,eAAe;kBADd,KAAK;YAIN,kBAAkB;kBADjB,KAAK;YAIN,eAAe;kBADd,MAAM;YAIP,mBAAmB;kBADlB,MAAM;YAIP,oBAAoB;kBADnB,MAAM;YAIP,MAAM;kBADL,MAAM;YAIP,SAAS;kBADR,MAAM;YASP,cAAc;kBADb,SAAS;mBAAC,UAAU","sourcesContent":["import { TagModule } from '@alauda/ui';\nimport { NgClass, NgFor, NgIf } from '@angular/common';\nimport {\n  ChangeDetectionStrategy,\n  Component,\n  EventEmitter,\n  Input,\n  Output,\n  ViewChild,\n} from '@angular/core';\nimport { FormsModule } from '@angular/forms';\n\nimport { PurePipeModule } from '../../scm';\nimport { MultiSearchActionInputComponent } from '../action-input/component';\nimport { SearchConditionConfig, SearchConditionModel } from '../types';\n\n@Component({\n  selector: 'acl-multi-search-tags',\n  standalone: true,\n  templateUrl: './template.html',\n  styleUrls: ['./styles.scss'],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  imports: [\n    NgIf,\n    NgFor,\n    TagModule,\n    NgClass,\n    PurePipeModule,\n    MultiSearchActionInputComponent,\n    FormsModule,\n  ],\n})\nexport class MultiSearchTagsComponent {\n  @Input()\n  placeholder: string;\n\n  @Input()\n  conditionCreatable: boolean;\n\n  @Input()\n  conditionConfig: SearchConditionConfig[];\n\n  @Input()\n  existingConditions: SearchConditionModel[];\n\n  @Output()\n  removeCondition = new EventEmitter<SearchConditionModel>();\n\n  @Output()\n  setConditionEditing = new EventEmitter<SearchConditionModel>();\n\n  @Output()\n  setConditionDeleting = new EventEmitter<number>();\n\n  @Output()\n  search = new EventEmitter<void>();\n\n  @Output()\n  completed = new EventEmitter<{\n    activeCondition: SearchConditionModel;\n    toContinue: boolean;\n    manualFocus: boolean;\n    index?: number;\n  }>();\n\n  @ViewChild('inputRef')\n  inputComponent: MultiSearchActionInputComponent;\n\n  conditionInAction(condition: SearchConditionModel) {\n    return condition.isEditing || condition.isDeleting;\n  }\n\n  getConditionLabel(condition: SearchConditionModel) {\n    return condition?.condition?.label ?? condition?.condition?.value;\n  }\n\n  getValueContent(condition: SearchConditionModel) {\n    return condition?.selectedValues\n      ?.map(value => value.label || value.value)\n      ?.join(condition.separator ?? '|');\n  }\n}\n","<div class=\"search-content\">\n  <ng-container *ngFor=\"let condition of existingConditions; let index = index\">\n    <aui-tag\n      *ngIf=\"!conditionInAction(condition); else inAction\"\n      class=\"tw-ml-6 tw-h-[22px] tw-mb-4\"\n      [ngClass]=\"condition.tagClass\"\n      [type]=\"condition.tagType || 'info'\"\n      [border]=\"true\"\n      [closeable]=\"true\"\n      (close)=\"removeCondition.emit(condition); search.emit()\"\n      (click)=\"setConditionEditing.emit(condition)\"\n      size=\"mini\"\n    >\n      <span\n        [title]=\"\n          (condition | pure: getConditionLabel) +\n          ' ' +\n          condition.operator +\n          ' ' +\n          (condition | pure: getValueContent)\n        \"\n      >\n        {{ condition | pure: getConditionLabel }}\n        {{ condition.operator }}\n        {{ condition | pure: getValueContent }}\n      </span>\n    </aui-tag>\n\n    <ng-template #inAction>\n      <acl-multi-search-action-input\n        #inputRef\n        class=\"input-wrapper\"\n        [ngClass]=\"{ 'deleting-input': condition.isDeleting }\"\n        [isEditing]=\"condition.isEditing\"\n        [conditionCreatable]=\"conditionCreatable\"\n        [placeholder]=\"placeholder\"\n        [conditionConfig]=\"conditionConfig\"\n        [existingConditions]=\"existingConditions\"\n        [(ngModel)]=\"condition.actionModel\"\n        (completed)=\"\n          completed.emit({\n            activeCondition: $event.activeCondition,\n            toContinue: $event.toContinue,\n            manualFocus: $event.manualFocus,\n            index: index\n          })\n        \"\n        (delete)=\"setConditionDeleting.emit(index - 1)\"\n        (editing)=\"setConditionEditing.emit(condition)\"\n        (search)=\"search.emit()\"\n      ></acl-multi-search-action-input>\n    </ng-template>\n  </ng-container>\n  <ng-content></ng-content>\n</div>\n"]}