@xw-components/condition-editor 18.1.0 → 18.1.1

package/condition-editor-request.service.d.ts

@@ -1,21 +1,78 @@
-import { InjectionToken } from '@angular/core';
+import { InjectionToken, WritableSignal } from '@angular/core';
 import { SelectOption } from './condition-editor.model';
 export declare const ConditionEditorRequestServiceToken: InjectionToken<ConditionEditorRequestService>;
 /**
  * 条件编辑器请求服务，用于获取选择框选项和操作符选项
  * 实现类需要根据前n个选择框的值来动态获取下一个选择框的选项。以及获取操作符选项。
+ * 需要实现getSelectOptions和getOperatorOptions方法
+ * 如果想要替换逻辑门的选项，需要重写getLogicGatesOptions方法
  */
 export declare abstract class ConditionEditorRequestService {
     constructor();
     /**
      * 获取选择框选项
-     * @param previousValue 前n个选择框的值
-     * @returns 选择框选项数组
+     * 实现类需要根据前n个选择框的值来动态获取下一个选择框的选项
+     * 例如：
+     * ```typescript
+     * getSelectOptions(previousValue: string[], writeSignal: WritableSignal<SelectOption[]>) {
+     *   if (previousValue.length === 0) {
+     *     writeSignal.set([
+     *       { label: '用户', value: 'user' },
+     *       { label: '订单', value: 'order' }
+     *     ]);
+     *   } else if (previousValue[0] === 'user') {
+     *     writeSignal.set([
+     *       { label: '用户名', value: 'username' },
+     *       { label: '邮箱', value: 'email' }
+     *     ]);
+     *   } else if (previousValue[0] === 'order') {
+     *     writeSignal.set([
+     *       { label: '订单号', value: 'orderNo' },
+     *       { label: '金额', value: 'amount' }
+     *     ]);
+     *   }
+     * }
+     * ```
+     *
+     * @param previousValue 前n个选择框的值，用于动态获取下一个选择框的选项
+     * @param writeSignal 用于写入选择框选项的信号量，用于在获取到选项后更新选择框的选项列表
      */
-    abstract getSelectOptions(previousValue: string[]): Promise<SelectOption[]>;
+    abstract getSelectOptions(previousValue: string[], writeSignal: WritableSignal<SelectOption[]>): void;
     /**
      * 获取操作符选项
-     * @returns 操作符选项数组
+     * 实现类使用入参信号的set方法设置操作符选项即可
+     * 例如：
+     * ```typescript
+     * getOperatorOptions(writeSignal: WritableSignal<SelectOption[]>) {
+     *   writeSignal.set([
+     *     { label: '等于', value: 'eq' },
+     *     { label: '不等于', value: 'ne' },
+     *     { label: '大于', value: 'gt' },
+     *     { label: '小于', value: 'lt' },
+     *     { label: '包含', value: 'contains' },
+     *     { label: '不包含', value: 'notContains' }
+     *   ]);
+     * }
+     * ```
+     *
+     * @param writeSignal 用于写入操作符选项的信号量，用于在获取到选项后更新操作符选择框的选项列表
      */
-    abstract getOperatorOptions(): Promise<SelectOption[]>;
+    abstract getOperatorOptions(writeSignal: WritableSignal<SelectOption[]>): void;
+    /**
+     * 获取逻辑门选项
+     * 重写方法使用入参信号的set方法设置逻辑门选项即可
+     * 例如：
+     * ```typescript
+     * getLogicGatesOptions(writeSignal: WritableSignal<SelectOption[]>) {
+     *   writeSignal.set([
+     *     { label: '且', value: 'AND' },
+     *     { label: '或', value: 'OR' },
+     *     { label: '非', value: 'NOT' }
+     *   ]);
+     * }
+     * ```
+     *
+     * @param writeSignal 用于写入逻辑门选项的信号量，用于在获取到选项后更新逻辑门选择框的选项列表
+     */
+    getLogicGatesOptions(writeSignal: WritableSignal<SelectOption[]>): void;
 }

package/condition-editor.component.d.ts

@@ -4,6 +4,85 @@ import * as i0 from "@angular/core";
 /**
  * 条件编辑器组件
  * 用于编辑条件表达式，支持多个条件组的组合。
+ * 例如：
+ * ```typescript
+ * // 1. 首先实现 ConditionEditorRequestService
+ * @Injectable({ providedIn: 'root' })
+ * export class MyConditionRequestService extends ConditionEditorRequestService {
+ *   getSelectOptions(previousValue: string[], writeSignal: WritableSignal<SelectOption[]>) {
+ *     if (previousValue.length === 0) {
+ *       writeSignal.set([
+ *         { label: '用户', value: 'user' },
+ *         { label: '订单', value: 'order' }
+ *       ]);
+ *     } else if (previousValue[0] === 'user') {
+ *       writeSignal.set([
+ *         { label: '用户名', value: 'username' },
+ *         { label: '邮箱', value: 'email' }
+ *       ]);
+ *     }
+ *   }
+ *
+ *   getOperatorOptions(writeSignal: WritableSignal<SelectOption[]>) {
+ *     writeSignal.set([
+ *       { label: '等于', value: 'eq' },
+ *       { label: '不等于', value: 'ne' },
+ *       { label: '包含', value: 'contains' }
+ *     ]);
+ *   }
+ * }
+ *
+ * // 2. 在模块中提供服务
+ * providers: [
+ *   { provide: ConditionEditorRequestServiceToken, useClass: MyConditionRequestService }
+ * ]
+ *
+ * // 3. 在父组件中使用
+ * @Component({
+ *   template: `
+ *     <app-condition-editor
+ *       [conditionData]="conditionData"
+ *       [showSelectNumber]="2"
+ *       [getIconFunc]="getIconFunc"
+ *       (dataChange)="onDataChange($event)">
+ *     </app-condition-editor>
+ *   `
+ * })
+ * export class ParentComponent {
+ *   conditionData: ConditionGroup = {
+ *     groupType: ConditionGroupType.AND,
+ *     conditions: []
+ *   };
+ *
+ *   getIconFunc = (value: string) => {
+ *     const iconMap: Record<string, string> = {
+ *       'user': 'icon-user',
+ *       'order': 'icon-order',
+ *       'username': 'icon-username',
+ *       'email': 'icon-email'
+ *     };
+ *     return iconMap[value] || 'icon-default';
+ *   };
+ *
+ *   onDataChange(data: ConditionGroup) {
+ *     console.log('条件数据变化:', data);
+ *     this.conditionData = data;
+ *   }
+ *
+ *   // 获取条件数据
+ *   getConditions() {
+ *     const editorComponent = this.conditionEditorRef;
+ *     return editorComponent.getConditionData();
+ *   }
+ *
+ *   // 重新加载选项
+ *   reloadOptions() {
+ *     const editorComponent = this.conditionEditorRef;
+ *     editorComponent.reloadFirstSelectOptions();
+ *     editorComponent.reloadOperatorOptions();
+ *   }
+ * }
+ * ```
  */
 export declare class ConditionEditorComponent implements OnInit {
     private readonly conditionEditorRequestService;

package/condition-editor.model.d.ts

@@ -17,6 +17,10 @@ export interface Condition {
 /**
  * 选择框选项
  * 用于条件编辑器中的选择框
+ * 例如：
+ * ```typescript
+ * { label: '用户', value: 'user', fieldType: 'user' }
+ * ```
  */
 export interface SelectOption {
     label: string;

package/condition-editor.service.d.ts

@@ -1,10 +1,13 @@
-import { BehaviorSubject } from 'rxjs';
+import { WritableSignal } from '@angular/core';
+import { Subject } from 'rxjs';
 import { SelectOption } from './condition-editor.model';
 import * as i0 from "@angular/core";
 export declare class ConditionEditorService {
-    operators: SelectOption[];
-    firstSelectOptionsSub: BehaviorSubject<SelectOption[]>;
-    showSelectNumberSub: BehaviorSubject<number>;
+    operators: WritableSignal<SelectOption[]>;
+    firstSelectOptions: WritableSignal<SelectOption[]>;
+    showSelectNumber: WritableSignal<number>;
+    logicGates: WritableSignal<SelectOption[]>;
+    changeSub: Subject<void>;
     getIconFunc?: (value: string) => string;
     static ɵfac: i0.ɵɵFactoryDeclaration<ConditionEditorService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<ConditionEditorService>;

package/condition-group/condition-group.component.d.ts

@@ -1,15 +1,14 @@
 import { ConditionGroup } from '../condition-editor.model';
+import { ConditionEditorService } from '../condition-editor.service';
 import * as i0 from "@angular/core";
 export declare class ConditionGroupComponent {
+    readonly conditionEditorService: ConditionEditorService;
     groupData: import("@angular/core").InputSignal<ConditionGroup>;
     parentData: import("@angular/core").InputSignal<ConditionGroup | null>;
     showLine: import("@angular/core").InputSignal<boolean>;
-    readonly dataChange: import("@angular/core").OutputEmitterRef<void>;
     addConditionItem(): void;
     addConditionGroup(): void;
     removeConditionGroup(): void;
-    submitForm(): void;
-    handleOk(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<ConditionGroupComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<ConditionGroupComponent, "app-condition-group", never, { "groupData": { "alias": "groupData"; "required": false; "isSignal": true; }; "parentData": { "alias": "parentData"; "required": false; "isSignal": true; }; "showLine": { "alias": "showLine"; "required": false; "isSignal": true; }; }, { "dataChange": "dataChange"; }, never, never, true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ConditionGroupComponent, "app-condition-group", never, { "groupData": { "alias": "groupData"; "required": false; "isSignal": true; }; "parentData": { "alias": "parentData"; "required": false; "isSignal": true; }; "showLine": { "alias": "showLine"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }

package/condition-item/condition-item.component.d.ts

@@ -1,9 +1,8 @@
-import { OnInit, OnDestroy } from '@angular/core';
-import { Subscription } from 'rxjs';
+import { WritableSignal } from '@angular/core';
 import { Condition, ConditionGroup, SelectOption } from '../condition-editor.model';
 import { ConditionEditorService } from '../condition-editor.service';
 import * as i0 from "@angular/core";
-export declare class ConditionItemComponent implements OnInit, OnDestroy {
+export declare class ConditionItemComponent {
     readonly conditionEditorService: ConditionEditorService;
     private readonly conditionEditorRequestService;
     conditionData: import("@angular/core").InputSignal<Condition>;
@@ -11,16 +10,15 @@ export declare class ConditionItemComponent implements OnInit, OnDestroy {
     dictOptions: never[];
     selectNumbers: number[];
     options: SelectOption[][];
-    firstSelectOptionsSub?: Subscription;
-    showSelectNumberSub?: Subscription;
-    readonly dataChange: import("@angular/core").OutputEmitterRef<void>;
-    ngOnInit(): void;
-    ngOnDestroy(): void;
+    optionsSignal: WritableSignal<SelectOption[]>;
+    changeIndex: number | null;
+    constructor();
     getIconfontByValue(value: string, option: SelectOption[]): string;
     hasIcon(option: SelectOption[]): boolean;
     removeConditionItem(): void;
     onSelectChange(index: number, event: any): void;
     onSelectOpenChange(index: number): void;
+    onOperatorChange(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<ConditionItemComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<ConditionItemComponent, "app-condition-item", never, { "conditionData": { "alias": "conditionData"; "required": false; "isSignal": true; }; "parentData": { "alias": "parentData"; "required": false; "isSignal": true; }; }, { "dataChange": "dataChange"; }, never, never, true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ConditionItemComponent, "app-condition-item", never, { "conditionData": { "alias": "conditionData"; "required": false; "isSignal": true; }; "parentData": { "alias": "parentData"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }

package/esm2022/condition-editor-request.service.mjs

@@ -3,8 +3,38 @@ export const ConditionEditorRequestServiceToken = new InjectionToken('ConditionE
 /**
  * 条件编辑器请求服务，用于获取选择框选项和操作符选项
  * 实现类需要根据前n个选择框的值来动态获取下一个选择框的选项。以及获取操作符选项。
+ * 需要实现getSelectOptions和getOperatorOptions方法
+ * 如果想要替换逻辑门的选项，需要重写getLogicGatesOptions方法
  */
 export class ConditionEditorRequestService {
     constructor() { }
+    /**
+     * 获取逻辑门选项
+     * 重写方法使用入参信号的set方法设置逻辑门选项即可
+     * 例如：
+     * ```typescript
+     * getLogicGatesOptions(writeSignal: WritableSignal<SelectOption[]>) {
+     *   writeSignal.set([
+     *     { label: '且', value: 'AND' },
+     *     { label: '或', value: 'OR' },
+     *     { label: '非', value: 'NOT' }
+     *   ]);
+     * }
+     * ```
+     *
+     * @param writeSignal 用于写入逻辑门选项的信号量，用于在获取到选项后更新逻辑门选择框的选项列表
+     */
+    getLogicGatesOptions(writeSignal) {
+        writeSignal.set([
+            {
+                label: '且',
+                value: 'AND'
+            },
+            {
+                label: '或',
+                value: 'OR'
+            }
+        ]);
+    }
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uZGl0aW9uLWVkaXRvci1yZXF1ZXN0LnNlcnZpY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9jb21wb25lbnRzL2NvbmRpdGlvbi1lZGl0b3IvY29uZGl0aW9uLWVkaXRvci1yZXF1ZXN0LnNlcnZpY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLGNBQWMsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUkvQyxNQUFNLENBQUMsTUFBTSxrQ0FBa0MsR0FBRyxJQUFJLGNBQWMsQ0FBZ0Msb0NBQW9DLENBQUMsQ0FBQztBQUUxSTs7O0dBR0c7QUFDSCxNQUFNLE9BQWdCLDZCQUE2QjtJQUNqRCxnQkFBZSxDQUFDO0NBWWpCIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW5qZWN0aW9uVG9rZW4gfSBmcm9tICdAYW5ndWxhci9jb3JlJztcblxuaW1wb3J0IHsgU2VsZWN0T3B0aW9uIH0gZnJvbSAnLi9jb25kaXRpb24tZWRpdG9yLm1vZGVsJztcblxuZXhwb3J0IGNvbnN0IENvbmRpdGlvbkVkaXRvclJlcXVlc3RTZXJ2aWNlVG9rZW4gPSBuZXcgSW5qZWN0aW9uVG9rZW48Q29uZGl0aW9uRWRpdG9yUmVxdWVzdFNlcnZpY2U+KCdDb25kaXRpb25FZGl0b3JSZXF1ZXN0U2VydmljZVRva2VuJyk7XG5cbi8qKlxuICog5p2h5Lu257yW6L6R5Zmo6K+35rGC5pyN5Yqh77yM55So5LqO6I635Y+W6YCJ5oup5qGG6YCJ6aG55ZKM5pON5L2c56ym6YCJ6aG5XG4gKiDlrp7njrDnsbvpnIDopoHmoLnmja7liY1u5Liq6YCJ5oup5qGG55qE5YC85p2l5Yqo5oCB6I635Y+W5LiL5LiA5Liq6YCJ5oup5qGG55qE6YCJ6aG544CC5Lul5Y+K6I635Y+W5pON5L2c56ym6YCJ6aG544CCXG4gKi9cbmV4cG9ydCBhYnN0cmFjdCBjbGFzcyBDb25kaXRpb25FZGl0b3JSZXF1ZXN0U2VydmljZSB7XG4gIGNvbnN0cnVjdG9yKCkge31cbiAgLyoqXG4gICAqIOiOt+WPlumAieaLqeahhumAiemhuVxuICAgKiBAcGFyYW0gcHJldmlvdXNWYWx1ZSDliY1u5Liq6YCJ5oup5qGG55qE5YC8XG4gICAqIEByZXR1cm5zIOmAieaLqeahhumAiemhueaVsOe7hFxuICAgKi9cbiAgYWJzdHJhY3QgZ2V0U2VsZWN0T3B0aW9ucyhwcmV2aW91c1ZhbHVlOiBzdHJpbmdbXSk6IFByb21pc2U8U2VsZWN0T3B0aW9uW10+O1xuICAvKipcbiAgICog6I635Y+W5pON5L2c56ym6YCJ6aG5XG4gICAqIEByZXR1cm5zIOaTjeS9nOespumAiemhueaVsOe7hFxuICAgKi9cbiAgYWJzdHJhY3QgZ2V0T3BlcmF0b3JPcHRpb25zKCk6IFByb21pc2U8U2VsZWN0T3B0aW9uW10+O1xufVxuIl19
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/condition-editor.component.mjs

@@ -7,6 +7,85 @@ import * as i0 from "@angular/core";
 /**
  * 条件编辑器组件
  * 用于编辑条件表达式，支持多个条件组的组合。
+ * 例如：
+ * ```typescript
+ * // 1. 首先实现 ConditionEditorRequestService
+ * @Injectable({ providedIn: 'root' })
+ * export class MyConditionRequestService extends ConditionEditorRequestService {
+ *   getSelectOptions(previousValue: string[], writeSignal: WritableSignal<SelectOption[]>) {
+ *     if (previousValue.length === 0) {
+ *       writeSignal.set([
+ *         { label: '用户', value: 'user' },
+ *         { label: '订单', value: 'order' }
+ *       ]);
+ *     } else if (previousValue[0] === 'user') {
+ *       writeSignal.set([
+ *         { label: '用户名', value: 'username' },
+ *         { label: '邮箱', value: 'email' }
+ *       ]);
+ *     }
+ *   }
+ *
+ *   getOperatorOptions(writeSignal: WritableSignal<SelectOption[]>) {
+ *     writeSignal.set([
+ *       { label: '等于', value: 'eq' },
+ *       { label: '不等于', value: 'ne' },
+ *       { label: '包含', value: 'contains' }
+ *     ]);
+ *   }
+ * }
+ *
+ * // 2. 在模块中提供服务
+ * providers: [
+ *   { provide: ConditionEditorRequestServiceToken, useClass: MyConditionRequestService }
+ * ]
+ *
+ * // 3. 在父组件中使用
+ * @Component({
+ *   template: `
+ *     <app-condition-editor
+ *       [conditionData]="conditionData"
+ *       [showSelectNumber]="2"
+ *       [getIconFunc]="getIconFunc"
+ *       (dataChange)="onDataChange($event)">
+ *     </app-condition-editor>
+ *   `
+ * })
+ * export class ParentComponent {
+ *   conditionData: ConditionGroup = {
+ *     groupType: ConditionGroupType.AND,
+ *     conditions: []
+ *   };
+ *
+ *   getIconFunc = (value: string) => {
+ *     const iconMap: Record<string, string> = {
+ *       'user': 'icon-user',
+ *       'order': 'icon-order',
+ *       'username': 'icon-username',
+ *       'email': 'icon-email'
+ *     };
+ *     return iconMap[value] || 'icon-default';
+ *   };
+ *
+ *   onDataChange(data: ConditionGroup) {
+ *     console.log('条件数据变化:', data);
+ *     this.conditionData = data;
+ *   }
+ *
+ *   // 获取条件数据
+ *   getConditions() {
+ *     const editorComponent = this.conditionEditorRef;
+ *     return editorComponent.getConditionData();
+ *   }
+ *
+ *   // 重新加载选项
+ *   reloadOptions() {
+ *     const editorComponent = this.conditionEditorRef;
+ *     editorComponent.reloadFirstSelectOptions();
+ *     editorComponent.reloadOperatorOptions();
+ *   }
+ * }
+ * ```
  */
 export class ConditionEditorComponent {
     constructor() {
@@ -34,9 +113,9 @@ export class ConditionEditorComponent {
         effect(() => {
             const showSelectNumber = this.showSelectNumber();
             if (showSelectNumber !== undefined) {
-                this.conditionEditorService.showSelectNumberSub.next(showSelectNumber);
+                this.conditionEditorService.showSelectNumber.set(showSelectNumber);
             }
-        });
+        }, { allowSignalWrites: true });
         effect(() => {
             const getIconFunc = this.getIconFunc();
             if (getIconFunc !== undefined) {
@@ -45,11 +124,11 @@ export class ConditionEditorComponent {
         });
     }
     ngOnInit() {
-        this.conditionEditorRequestService.getOperatorOptions().then(options => {
-            this.conditionEditorService.operators = options || [];
-        });
-        this.conditionEditorRequestService.getSelectOptions([]).then(options => {
-            this.conditionEditorService.firstSelectOptionsSub.next(options || []);
+        this.conditionEditorRequestService.getOperatorOptions(this.conditionEditorService.operators);
+        this.conditionEditorRequestService.getLogicGatesOptions(this.conditionEditorService.logicGates);
+        this.conditionEditorRequestService.getSelectOptions([], this.conditionEditorService.firstSelectOptions);
+        this.conditionEditorService.changeSub.subscribe(() => {
+            this.onDataChange();
         });
     }
     onDataChange() {
@@ -66,23 +145,19 @@ export class ConditionEditorComponent {
      * 重新加载第一个选择框的选项
      */
     reloadFirstSelectOptions() {
-        this.conditionEditorRequestService.getSelectOptions([]).then(options => {
-            this.conditionEditorService.firstSelectOptionsSub.next(options || []);
-        });
+        this.conditionEditorRequestService.getSelectOptions([], this.conditionEditorService.firstSelectOptions);
     }
     /**
      * 重新加载操作符选项
      */
     reloadOperatorOptions() {
-        this.conditionEditorRequestService.getOperatorOptions().then(options => {
-            this.conditionEditorService.operators = options || [];
-        });
+        this.conditionEditorRequestService.getOperatorOptions(this.conditionEditorService.operators);
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ConditionEditorComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
-    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.1.0", version: "18.2.14", type: ConditionEditorComponent, isStandalone: true, selector: "app-condition-editor", inputs: { conditionData: { classPropertyName: "conditionData", publicName: "conditionData", isSignal: true, isRequired: false, transformFunction: null }, showSelectNumber: { classPropertyName: "showSelectNumber", publicName: "showSelectNumber", isSignal: true, isRequired: false, transformFunction: null }, getIconFunc: { classPropertyName: "getIconFunc", publicName: "getIconFunc", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { dataChange: "dataChange" }, providers: [ConditionEditorService], ngImport: i0, template: "<div class=\"condition-editor\">\n  <app-condition-group [showLine]=\"false\" [groupData]=\"conditionData()\" (dataChange)=\"onDataChange()\"></app-condition-group>\n</div>\n", styles: [":host{display:block}:host .condition-editor{padding-bottom:12px}\n"], dependencies: [{ kind: "component", type: ConditionGroupComponent, selector: "app-condition-group", inputs: ["groupData", "parentData", "showLine"], outputs: ["dataChange"] }] }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.1.0", version: "18.2.14", type: ConditionEditorComponent, isStandalone: true, selector: "app-condition-editor", inputs: { conditionData: { classPropertyName: "conditionData", publicName: "conditionData", isSignal: true, isRequired: false, transformFunction: null }, showSelectNumber: { classPropertyName: "showSelectNumber", publicName: "showSelectNumber", isSignal: true, isRequired: false, transformFunction: null }, getIconFunc: { classPropertyName: "getIconFunc", publicName: "getIconFunc", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { dataChange: "dataChange" }, providers: [ConditionEditorService], ngImport: i0, template: "<div class=\"condition-editor\">\n  <app-condition-group [showLine]=\"false\" [groupData]=\"conditionData()\"></app-condition-group>\n</div>\n", styles: [":host{display:block}:host .condition-editor{padding-bottom:12px}\n"], dependencies: [{ kind: "component", type: ConditionGroupComponent, selector: "app-condition-group", inputs: ["groupData", "parentData", "showLine"] }] }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ConditionEditorComponent, decorators: [{
             type: Component,
-            args: [{ selector: 'app-condition-editor', standalone: true, imports: [ConditionGroupComponent], providers: [ConditionEditorService], template: "<div class=\"condition-editor\">\n  <app-condition-group [showLine]=\"false\" [groupData]=\"conditionData()\" (dataChange)=\"onDataChange()\"></app-condition-group>\n</div>\n", styles: [":host{display:block}:host .condition-editor{padding-bottom:12px}\n"] }]
+            args: [{ selector: 'app-condition-editor', standalone: true, imports: [ConditionGroupComponent], providers: [ConditionEditorService], template: "<div class=\"condition-editor\">\n  <app-condition-group [showLine]=\"false\" [groupData]=\"conditionData()\"></app-condition-group>\n</div>\n", styles: [":host{display:block}:host .condition-editor{padding-bottom:12px}\n"] }]
         }], ctorParameters: () => [] });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"condition-editor.component.js","sourceRoot":"","sources":["../../../../components/condition-editor/condition-editor.component.ts","../../../../components/condition-editor/condition-editor.component.html"],"names":[],"mappings":"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","sourcesContent":["import { Component, inject, input, output, OnInit, effect, untracked, computed } from '@angular/core';\n\nimport { ConditionEditorRequestService, ConditionEditorRequestServiceToken } from './condition-editor-request.service';\nimport { ConditionGroup, ConditionGroupType } from './condition-editor.model';\nimport { ConditionEditorService } from './condition-editor.service';\nimport { ConditionGroupComponent } from './condition-group/condition-group.component';\n\n/**\n * 条件编辑器组件\n * 用于编辑条件表达式，支持多个条件组的组合。\n * 例如：\n * ```typescript\n * // 1. 首先实现 ConditionEditorRequestService\n * @Injectable({ providedIn: 'root' })\n * export class MyConditionRequestService extends ConditionEditorRequestService {\n *   getSelectOptions(previousValue: string[], writeSignal: WritableSignal<SelectOption[]>) {\n *     if (previousValue.length === 0) {\n *       writeSignal.set([\n *         { label: '用户', value: 'user' },\n *         { label: '订单', value: 'order' }\n *       ]);\n *     } else if (previousValue[0] === 'user') {\n *       writeSignal.set([\n *         { label: '用户名', value: 'username' },\n *         { label: '邮箱', value: 'email' }\n *       ]);\n *     }\n *   }\n *\n *   getOperatorOptions(writeSignal: WritableSignal<SelectOption[]>) {\n *     writeSignal.set([\n *       { label: '等于', value: 'eq' },\n *       { label: '不等于', value: 'ne' },\n *       { label: '包含', value: 'contains' }\n *     ]);\n *   }\n * }\n *\n * // 2. 在模块中提供服务\n * providers: [\n *   { provide: ConditionEditorRequestServiceToken, useClass: MyConditionRequestService }\n * ]\n *\n * // 3. 在父组件中使用\n * @Component({\n *   template: `\n *     <app-condition-editor\n *       [conditionData]=\"conditionData\"\n *       [showSelectNumber]=\"2\"\n *       [getIconFunc]=\"getIconFunc\"\n *       (dataChange)=\"onDataChange($event)\">\n *     </app-condition-editor>\n *   `\n * })\n * export class ParentComponent {\n *   conditionData: ConditionGroup = {\n *     groupType: ConditionGroupType.AND,\n *     conditions: []\n *   };\n *\n *   getIconFunc = (value: string) => {\n *     const iconMap: Record<string, string> = {\n *       'user': 'icon-user',\n *       'order': 'icon-order',\n *       'username': 'icon-username',\n *       'email': 'icon-email'\n *     };\n *     return iconMap[value] || 'icon-default';\n *   };\n *\n *   onDataChange(data: ConditionGroup) {\n *     console.log('条件数据变化:', data);\n *     this.conditionData = data;\n *   }\n *\n *   // 获取条件数据\n *   getConditions() {\n *     const editorComponent = this.conditionEditorRef;\n *     return editorComponent.getConditionData();\n *   }\n *\n *   // 重新加载选项\n *   reloadOptions() {\n *     const editorComponent = this.conditionEditorRef;\n *     editorComponent.reloadFirstSelectOptions();\n *     editorComponent.reloadOperatorOptions();\n *   }\n * }\n * ```\n */\n@Component({\n  selector: 'app-condition-editor',\n  standalone: true,\n  imports: [ConditionGroupComponent],\n  templateUrl: './condition-editor.component.html',\n  styleUrl: './condition-editor.component.less',\n  providers: [ConditionEditorService]\n})\nexport class ConditionEditorComponent implements OnInit {\n  private readonly conditionEditorRequestService = inject<ConditionEditorRequestService>(ConditionEditorRequestServiceToken);\n  private readonly conditionEditorService = inject(ConditionEditorService);\n  /**\n   * 条件数据输入，包含条件组类型和条件数组\n   */\n  conditionData = input<ConditionGroup>({\n    groupType: ConditionGroupType.AND,\n    conditions: []\n  });\n  /**\n   * 显示选择框的数量输入\n   */\n  showSelectNumber = input<number>();\n\n  /**\n   * 图标函数输入，用于根据值返回图标字体名\n   */\n  getIconFunc = input<(value: string) => string>();\n  /**\n   * 条件数据变化输出，包含更新后的条件组\n   */\n  readonly dataChange = output<ConditionGroup>();\n\n  constructor() {\n    effect(\n      () => {\n        const showSelectNumber = this.showSelectNumber();\n        if (showSelectNumber !== undefined) {\n          this.conditionEditorService.showSelectNumber.set(showSelectNumber);\n        }\n      },\n      { allowSignalWrites: true }\n    );\n\n    effect(() => {\n      const getIconFunc = this.getIconFunc();\n      if (getIconFunc !== undefined) {\n        this.conditionEditorService.getIconFunc = getIconFunc;\n      }\n    });\n  }\n\n  ngOnInit() {\n    this.conditionEditorRequestService.getOperatorOptions(this.conditionEditorService.operators);\n    this.conditionEditorRequestService.getLogicGatesOptions(this.conditionEditorService.logicGates);\n    this.conditionEditorRequestService.getSelectOptions([], this.conditionEditorService.firstSelectOptions);\n    this.conditionEditorService.changeSub.subscribe(() => {\n      this.onDataChange();\n    });\n  }\n\n  onDataChange() {\n    this.dataChange.emit(this.conditionData());\n  }\n\n  /**\n   * 获取当前条件数据\n   * @returns 当前条件数据\n   */\n  public getConditionData() {\n    return this.conditionData();\n  }\n\n  /**\n   * 重新加载第一个选择框的选项\n   */\n  public reloadFirstSelectOptions() {\n    this.conditionEditorRequestService.getSelectOptions([], this.conditionEditorService.firstSelectOptions);\n  }\n\n  /**\n   * 重新加载操作符选项\n   */\n  public reloadOperatorOptions() {\n    this.conditionEditorRequestService.getOperatorOptions(this.conditionEditorService.operators);\n  }\n}\n","<div class=\"condition-editor\">\n  <app-condition-group [showLine]=\"false\" [groupData]=\"conditionData()\"></app-condition-group>\n</div>\n"]}

package/esm2022/condition-editor.model.mjs

@@ -3,4 +3,4 @@ export var ConditionGroupType;
     ConditionGroupType["AND"] = "AND";
     ConditionGroupType["OR"] = "OR";
 })(ConditionGroupType || (ConditionGroupType = {}));
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uZGl0aW9uLWVkaXRvci5tb2RlbC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL2NvbXBvbmVudHMvY29uZGl0aW9uLWVkaXRvci9jb25kaXRpb24tZWRpdG9yLm1vZGVsLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE1BQU0sQ0FBTixJQUFZLGtCQUdYO0FBSEQsV0FBWSxrQkFBa0I7SUFDNUIsaUNBQVcsQ0FBQTtJQUNYLCtCQUFTLENBQUE7QUFDWCxDQUFDLEVBSFcsa0JBQWtCLEtBQWxCLGtCQUFrQixRQUc3QiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBlbnVtIENvbmRpdGlvbkdyb3VwVHlwZSB7XG4gIEFORCA9ICdBTkQnLFxuICBPUiA9ICdPUidcbn1cblxuZXhwb3J0IGludGVyZmFjZSBDb25kaXRpb25Hcm91cCB7XG4gIGdyb3VwVHlwZTogQ29uZGl0aW9uR3JvdXBUeXBlO1xuICBjb25kaXRpb25zOiBBcnJheTxDb25kaXRpb24gfCBDb25kaXRpb25Hcm91cD47XG59XG5cbmV4cG9ydCBpbnRlcmZhY2UgQ29uZGl0aW9uIHtcbiAga2V5czogQXJyYXk8eyBsYWJlbDogc3RyaW5nOyB2YWx1ZTogc3RyaW5nIH0+O1xuICBvcGVyYXRvcjogc3RyaW5nO1xuICB2YWx1ZTogYW55O1xufVxuXG4vKipcbiAqIOmAieaLqeahhumAiemhuVxuICog55So5LqO5p2h5Lu257yW6L6R5Zmo5Lit55qE6YCJ5oup5qGGXG4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgU2VsZWN0T3B0aW9uIHtcbiAgbGFiZWw6IHN0cmluZztcbiAgdmFsdWU6IHN0cmluZztcbiAgZmllbGRUeXBlPzogc3RyaW5nO1xufVxuIl19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uZGl0aW9uLWVkaXRvci5tb2RlbC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL2NvbXBvbmVudHMvY29uZGl0aW9uLWVkaXRvci9jb25kaXRpb24tZWRpdG9yLm1vZGVsLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE1BQU0sQ0FBTixJQUFZLGtCQUdYO0FBSEQsV0FBWSxrQkFBa0I7SUFDNUIsaUNBQVcsQ0FBQTtJQUNYLCtCQUFTLENBQUE7QUFDWCxDQUFDLEVBSFcsa0JBQWtCLEtBQWxCLGtCQUFrQixRQUc3QiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBlbnVtIENvbmRpdGlvbkdyb3VwVHlwZSB7XG4gIEFORCA9ICdBTkQnLFxuICBPUiA9ICdPUidcbn1cblxuZXhwb3J0IGludGVyZmFjZSBDb25kaXRpb25Hcm91cCB7XG4gIGdyb3VwVHlwZTogQ29uZGl0aW9uR3JvdXBUeXBlO1xuICBjb25kaXRpb25zOiBBcnJheTxDb25kaXRpb24gfCBDb25kaXRpb25Hcm91cD47XG59XG5cbmV4cG9ydCBpbnRlcmZhY2UgQ29uZGl0aW9uIHtcbiAga2V5czogQXJyYXk8eyBsYWJlbDogc3RyaW5nOyB2YWx1ZTogc3RyaW5nIH0+O1xuICBvcGVyYXRvcjogc3RyaW5nO1xuICB2YWx1ZTogYW55O1xufVxuXG4vKipcbiAqIOmAieaLqeahhumAiemhuVxuICog55So5LqO5p2h5Lu257yW6L6R5Zmo5Lit55qE6YCJ5oup5qGGXG4gKiDkvovlpoLvvJpcbiAqIGBgYHR5cGVzY3JpcHRcbiAqIHsgbGFiZWw6ICfnlKjmiLcnLCB2YWx1ZTogJ3VzZXInLCBmaWVsZFR5cGU6ICd1c2VyJyB9XG4gKiBgYGBcbiAqL1xuZXhwb3J0IGludGVyZmFjZSBTZWxlY3RPcHRpb24ge1xuICBsYWJlbDogc3RyaW5nO1xuICB2YWx1ZTogc3RyaW5nO1xuICBmaWVsZFR5cGU/OiBzdHJpbmc7XG59XG4iXX0=

package/esm2022/condition-editor.service.mjs

@@ -1,11 +1,13 @@
-import { Injectable } from '@angular/core';
-import { BehaviorSubject } from 'rxjs';
+import { Injectable, signal } from '@angular/core';
+import { Subject } from 'rxjs';
 import * as i0 from "@angular/core";
 export class ConditionEditorService {
     constructor() {
-        this.operators = [];
-        this.firstSelectOptionsSub = new BehaviorSubject([]);
-        this.showSelectNumberSub = new BehaviorSubject(1);
+        this.operators = signal([]);
+        this.firstSelectOptions = signal([]);
+        this.showSelectNumber = signal(1);
+        this.logicGates = signal([]);
+        this.changeSub = new Subject();
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ConditionEditorService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
     static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ConditionEditorService }); }
@@ -13,4 +15,4 @@ export class ConditionEditorService {
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ConditionEditorService, decorators: [{
             type: Injectable
         }] });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uZGl0aW9uLWVkaXRvci5zZXJ2aWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vY29tcG9uZW50cy9jb25kaXRpb24tZWRpdG9yL2NvbmRpdGlvbi1lZGl0b3Iuc2VydmljZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBQzNDLE9BQU8sRUFBRSxlQUFlLEVBQUUsTUFBTSxNQUFNLENBQUM7O0FBS3ZDLE1BQU0sT0FBTyxzQkFBc0I7SUFEbkM7UUFFRSxjQUFTLEdBQW1CLEVBQUUsQ0FBQztRQUUvQiwwQkFBcUIsR0FBRyxJQUFJLGVBQWUsQ0FBaUIsRUFBRSxDQUFDLENBQUM7UUFFaEUsd0JBQW1CLEdBQUcsSUFBSSxlQUFlLENBQVMsQ0FBQyxDQUFDLENBQUM7S0FHdEQ7K0dBUlksc0JBQXNCO21IQUF0QixzQkFBc0I7OzRGQUF0QixzQkFBc0I7a0JBRGxDLFVBQVUiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJbmplY3RhYmxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBCZWhhdmlvclN1YmplY3QgfSBmcm9tICdyeGpzJztcblxuaW1wb3J0IHsgU2VsZWN0T3B0aW9uIH0gZnJvbSAnLi9jb25kaXRpb24tZWRpdG9yLm1vZGVsJztcblxuQEluamVjdGFibGUoKVxuZXhwb3J0IGNsYXNzIENvbmRpdGlvbkVkaXRvclNlcnZpY2Uge1xuICBvcGVyYXRvcnM6IFNlbGVjdE9wdGlvbltdID0gW107XG5cbiAgZmlyc3RTZWxlY3RPcHRpb25zU3ViID0gbmV3IEJlaGF2aW9yU3ViamVjdDxTZWxlY3RPcHRpb25bXT4oW10pO1xuXG4gIHNob3dTZWxlY3ROdW1iZXJTdWIgPSBuZXcgQmVoYXZpb3JTdWJqZWN0PG51bWJlcj4oMSk7XG5cbiAgZ2V0SWNvbkZ1bmM/OiAodmFsdWU6IHN0cmluZykgPT4gc3RyaW5nO1xufVxuIl19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uZGl0aW9uLWVkaXRvci5zZXJ2aWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vY29tcG9uZW50cy9jb25kaXRpb24tZWRpdG9yL2NvbmRpdGlvbi1lZGl0b3Iuc2VydmljZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sRUFBa0IsTUFBTSxlQUFlLENBQUM7QUFDbkUsT0FBTyxFQUFtQixPQUFPLEVBQUUsTUFBTSxNQUFNLENBQUM7O0FBS2hELE1BQU0sT0FBTyxzQkFBc0I7SUFEbkM7UUFFRSxjQUFTLEdBQW1DLE1BQU0sQ0FBQyxFQUFFLENBQUMsQ0FBQztRQUV2RCx1QkFBa0IsR0FBbUMsTUFBTSxDQUFDLEVBQUUsQ0FBQyxDQUFDO1FBRWhFLHFCQUFnQixHQUEyQixNQUFNLENBQUMsQ0FBQyxDQUFDLENBQUM7UUFFckQsZUFBVSxHQUFtQyxNQUFNLENBQUMsRUFBRSxDQUFDLENBQUM7UUFFeEQsY0FBUyxHQUFHLElBQUksT0FBTyxFQUFRLENBQUM7S0FHakM7K0dBWlksc0JBQXNCO21IQUF0QixzQkFBc0I7OzRGQUF0QixzQkFBc0I7a0JBRGxDLFVBQVUiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJbmplY3RhYmxlLCBzaWduYWwsIFdyaXRhYmxlU2lnbmFsIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBCZWhhdmlvclN1YmplY3QsIFN1YmplY3QgfSBmcm9tICdyeGpzJztcblxuaW1wb3J0IHsgU2VsZWN0T3B0aW9uIH0gZnJvbSAnLi9jb25kaXRpb24tZWRpdG9yLm1vZGVsJztcblxuQEluamVjdGFibGUoKVxuZXhwb3J0IGNsYXNzIENvbmRpdGlvbkVkaXRvclNlcnZpY2Uge1xuICBvcGVyYXRvcnM6IFdyaXRhYmxlU2lnbmFsPFNlbGVjdE9wdGlvbltdPiA9IHNpZ25hbChbXSk7XG5cbiAgZmlyc3RTZWxlY3RPcHRpb25zOiBXcml0YWJsZVNpZ25hbDxTZWxlY3RPcHRpb25bXT4gPSBzaWduYWwoW10pO1xuXG4gIHNob3dTZWxlY3ROdW1iZXI6IFdyaXRhYmxlU2lnbmFsPG51bWJlcj4gPSBzaWduYWwoMSk7XG5cbiAgbG9naWNHYXRlczogV3JpdGFibGVTaWduYWw8U2VsZWN0T3B0aW9uW10+ID0gc2lnbmFsKFtdKTtcblxuICBjaGFuZ2VTdWIgPSBuZXcgU3ViamVjdDx2b2lkPigpO1xuXG4gIGdldEljb25GdW5jPzogKHZhbHVlOiBzdHJpbmcpID0+IHN0cmluZztcbn1cbiJdfQ==