@yibozhang/pro-table 0.0.3 → 0.0.4

package/esm2015/lib/page-public/array-form.js

@@ -0,0 +1,269 @@
+import { Injectable } from "@angular/core";
+import { v4 as uuidv4 } from "uuid";
+import * as i0 from "@angular/core";
+/**
+ * 数组型数据收集基础服务
+ *
+ * 功能：
+ * 1. 支持通过 ngModel 绑定对应行的数据源
+ * 2. 自动为数组数据添加 isEdit 和 uid 字段
+ * 3. 支持每个字段的自定义校验方法，返回 'success' | 'warning' | 'error'
+ * 4. 提供公共方法支持删除、新增、编辑等操作
+ */
+export class ArrayFormService {
+    constructor() {
+        this.formStore = {};
+    }
+    /**
+     * 初始化数组数据
+     * 为现有数据添加 uid 和 isEdit 字段
+     *
+     * @param data 原始数据数组
+     * @param config 表单配置
+     * @returns 初始化后的数据数组
+     */
+    initializeData(data) {
+        return data.map((item) => this.enrichRow(item));
+    }
+    /**
+     * 为单行数据添加 uid 和 isEdit 字段
+     *
+     * @param row 原始行数据
+     * @returns 增强后的行数据
+     */
+    enrichRow(row) {
+        return Object.assign(Object.assign({}, row), { uid: row.uid || uuidv4(), isEdit: row.isEdit !== undefined ? row.isEdit : false });
+    }
+    /**
+     * 新增一行数据
+     *
+     * @param data 数据数组引用
+     * @param defaultValues 默认值
+     * @returns 新增的行数据
+     */
+    addRow(data, defaultValues) {
+        const newRow = Object.assign(Object.assign({}, defaultValues), { uid: uuidv4(), isEdit: true, isAdd: true });
+        data.push(newRow);
+        return newRow;
+    }
+    /**
+     * 校验单个字段
+     *
+     * @param row 行数据
+     * @param fieldName 字段名
+     * @param config 表单配置
+     * @returns 校验结果
+     */
+    validateField(row, fieldName, config) {
+        const fieldConfig = config.fields.find((f) => f.name === fieldName);
+        if (!fieldConfig) {
+            return "";
+        }
+        if (fieldConfig.validator) {
+            return fieldConfig.validator(row[fieldName], row, fieldName);
+        }
+        return "";
+    }
+    /**
+     * 校验整行数据
+     *
+     * @param row 行数据
+     * @param config 表单配置
+     * @returns 校验结果对象，key为字段名，value为校验结果
+     */
+    validateRow(row, config) {
+        const results = {};
+        config.fields.forEach((fieldConfig) => {
+            results[fieldConfig.name] = this.validateField(row, fieldConfig.name, config);
+        });
+        return results;
+    }
+    /**
+     * 校验整个数组
+     *
+     * @param data 数据数组
+     * @param config 表单配置
+     * @returns 校验结果对象，key为行的uid，value为该行的校验结果
+     */
+    validateData(data, config) {
+        const results = {};
+        data.forEach((row) => {
+            results[row.uid] = this.validateRow(row, config);
+        });
+        return results;
+    }
+    /**
+     * 注册表单到存储
+     * 如果表单已存在，则更新其配置
+     *
+     * @param formName 表单名称
+     * @param data 数据数组
+     * @param config 表单配置
+     */
+    registerForm(formName, data, config) {
+        this.formStore[formName] = {
+            data: this.initializeData(data),
+            config,
+            validationResults: {},
+        };
+        // 如果配置了自动更新，立即更新一次
+        this.autoUpdateArrayReference(formName);
+    }
+    /**
+     * 从存储中获取表单
+     *
+     * @param formName 表单名称
+     * @returns 表单存储项或undefined
+     */
+    getForm(formName) {
+        return this.formStore[formName];
+    }
+    /**
+     * 向表单添加行
+     *
+     * @param formName 表单名称
+     * @param defaultValues 默认值
+     * @returns 新增的行数据或undefined
+     */
+    addRowToForm(formName, defaultValues) {
+        const form = this.formStore[formName];
+        if (!form) {
+            return undefined;
+        }
+        const newRow = this.addRow(form.data, defaultValues);
+        // 自动更新外部数组引用
+        this.autoUpdateArrayReference(formName);
+        return newRow;
+    }
+    /**
+     * 校验表单
+     *
+     * @param formName 表单名称
+     * @returns 校验结果或undefined
+     */
+    validateForm(formName) {
+        const form = this.formStore[formName];
+        if (!form) {
+            return undefined;
+        }
+        const results = this.validateData(form.data, form.config);
+        form.validationResults = results;
+        return results;
+    }
+    /**
+     * 开启指定行的编辑模式
+     *
+     * @param row 行数据
+     */
+    enableEdit(row) {
+        row.isEdit = true;
+    }
+    /**
+     * 关闭指定行的编辑模式
+     *
+     * @param row 行数据
+     */
+    disableEdit(row) {
+        row.isEdit = false;
+    }
+    /**
+     * 从表单中删除指定行
+     *
+     * @param formName 表单名称
+     * @param row 行的uid
+     * @returns 是否删除成功
+     */
+    deleteRowFromForm(formName, row) {
+        const form = this.formStore[formName];
+        if (!form) {
+            return false;
+        }
+        const index = form.data.findIndex((item) => item.uid === row.uid);
+        if (index === -1) {
+            return false;
+        }
+        form.data.splice(index, 1);
+        if (form.validationResults && form.validationResults[row.uid]) {
+            delete form.validationResults[row.uid];
+        }
+        // 自动更新外部数组引用
+        this.autoUpdateArrayReference(formName);
+        return true;
+    }
+    /**
+     * 校验指定行的指定字段并返回校验结果
+     * 实时执行校验，用于模板中的实时校验显示
+     *
+     * @param formName 表单名称
+     * @param row 行数据
+     * @param fieldName 字段名
+     * @returns 校验结果
+     */
+    validateFieldInRow(formName, row, fieldName) {
+        const form = this.formStore[formName];
+        if (!form) {
+            return "success";
+        }
+        const fieldConfig = form.config.fields.find((f) => f.name === fieldName);
+        if (!fieldConfig) {
+            return "success";
+        }
+        let result = "";
+        if (fieldConfig.validator) {
+            result = fieldConfig.validator(row[fieldName], row, fieldName);
+        }
+        // 更新校验结果存储
+        if (!form.validationResults) {
+            form.validationResults = {};
+        }
+        if (!form.validationResults[row.uid]) {
+            form.validationResults[row.uid] = {};
+        }
+        form.validationResults[row.uid][fieldName] = result;
+        return result ? "error" : "success";
+    }
+    /**
+     * 校验指定行的所有字段
+     *
+     * @param formName 表单名称
+     * @param row 行数据
+     * @returns 是否所有字段都通过校验
+     */
+    validateRowAllFields(formName, row) {
+        const form = this.formStore[formName];
+        if (!form) {
+            return true;
+        }
+        let hasError = false;
+        form.config.fields.forEach((fieldConfig) => {
+            const result = this.validateFieldInRow(formName, row, fieldConfig.name);
+            if (result === "error") {
+                hasError = true;
+            }
+        });
+        return !hasError;
+    }
+    /**
+     * 自动更新外部数组引用（如果配置了）
+     * 私有方法，在数据变化时自动调用
+     *
+     * @param formName 表单名称
+     */
+    autoUpdateArrayReference(formName) {
+        const form = this.formStore[formName];
+        if (!form || !form.config.targetObject || !form.config.arrayPropertyName) {
+            return;
+        }
+        const newArray = form.data ? [...form.data] : [];
+        // 更新目标对象的数组属性为新数组引用
+        form.config.targetObject[form.config.arrayPropertyName] = newArray;
+    }
+}
+ArrayFormService.ɵprov = i0.ɵɵdefineInjectable({ factory: function ArrayFormService_Factory() { return new ArrayFormService(); }, token: ArrayFormService, providedIn: "root" });
+ArrayFormService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: "root",
+            },] }
+];
+ArrayFormService.ctorParameters = () => [];
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"array-form.js","sourceRoot":"D:/projects/vps-front/Front/DasPMSWeb/lib/pro-table/src/","sources":["lib/page-public/array-form.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from \"@angular/core\";\r\nimport { v4 as uuidv4 } from \"uuid\";\r\n\r\n/**\r\n * 字段校验结果类型\r\n */\r\nexport type ValidationResult = string;\r\n\r\n/**\r\n * 字段校验方法类型\r\n */\r\nexport type FieldValidator = (\r\n  value: any,\r\n  row: ArrayFormRow,\r\n  fieldName: string\r\n) => ValidationResult;\r\n\r\n/**\r\n * 字段配置接口\r\n */\r\nexport interface FieldConfig {\r\n  name: string;\r\n  validator?: FieldValidator;\r\n}\r\n\r\n/**\r\n * 数组表单行数据接口\r\n */\r\nexport interface ArrayFormRow {\r\n  uid: string;\r\n  isEdit: boolean;\r\n  isAdd?: boolean;\r\n  [key: string]: any;\r\n}\r\n\r\n/**\r\n * 数组表单配置接口\r\n */\r\nexport interface ArrayFormConfig {\r\n  fields: FieldConfig[];\r\n  defaultValues?: Record<string, any>;\r\n  // 自动更新目标对象和属性名，用于触发 Angular 变化检测\r\n  targetObject?: Record<string, any>;\r\n  arrayPropertyName?: string;\r\n}\r\n\r\n/**\r\n * 表单存储项接口\r\n */\r\nexport interface ArrayFormStoreItem {\r\n  data: ArrayFormRow[];\r\n  config: ArrayFormConfig;\r\n  validationResults?: Record<string, Record<string, ValidationResult>>;\r\n}\r\n\r\n/**\r\n * 表单存储接口\r\n */\r\nexport interface ArrayFormStore {\r\n  [formName: string]: ArrayFormStoreItem;\r\n}\r\n\r\n/**\r\n * 数组型数据收集基础服务\r\n *\r\n * 功能：\r\n * 1. 支持通过 ngModel 绑定对应行的数据源\r\n * 2. 自动为数组数据添加 isEdit 和 uid 字段\r\n * 3. 支持每个字段的自定义校验方法，返回 'success' | 'warning' | 'error'\r\n * 4. 提供公共方法支持删除、新增、编辑等操作\r\n */\r\n@Injectable({\r\n  providedIn: \"root\",\r\n})\r\nexport class ArrayFormService {\r\n  private formStore: ArrayFormStore = {};\r\n\r\n  constructor() {}\r\n\r\n  /**\r\n   * 初始化数组数据\r\n   * 为现有数据添加 uid 和 isEdit 字段\r\n   *\r\n   * @param data 原始数据数组\r\n   * @param config 表单配置\r\n   * @returns 初始化后的数据数组\r\n   */\r\n  private initializeData(data: any[]): ArrayFormRow[] {\r\n    return data.map((item) => this.enrichRow(item));\r\n  }\r\n\r\n  /**\r\n   * 为单行数据添加 uid 和 isEdit 字段\r\n   *\r\n   * @param row 原始行数据\r\n   * @returns 增强后的行数据\r\n   */\r\n  private enrichRow(row: any): ArrayFormRow {\r\n    return {\r\n      ...row,\r\n      uid: row.uid || uuidv4(),\r\n      isEdit: row.isEdit !== undefined ? row.isEdit : false,\r\n    };\r\n  }\r\n\r\n  /**\r\n   * 新增一行数据\r\n   *\r\n   * @param data 数据数组引用\r\n   * @param defaultValues 默认值\r\n   * @returns 新增的行数据\r\n   */\r\n  private addRow(\r\n    data: ArrayFormRow[],\r\n    defaultValues?: Record<string, any>\r\n  ): ArrayFormRow {\r\n    const newRow: ArrayFormRow = {\r\n      ...defaultValues,\r\n      uid: uuidv4(),\r\n      isEdit: true,\r\n      isAdd: true,\r\n    };\r\n    data.push(newRow);\r\n    return newRow;\r\n  }\r\n\r\n  /**\r\n   * 校验单个字段\r\n   *\r\n   * @param row 行数据\r\n   * @param fieldName 字段名\r\n   * @param config 表单配置\r\n   * @returns 校验结果\r\n   */\r\n  private validateField(\r\n    row: ArrayFormRow,\r\n    fieldName: string,\r\n    config: ArrayFormConfig\r\n  ): ValidationResult {\r\n    const fieldConfig = config.fields.find((f) => f.name === fieldName);\r\n\r\n    if (!fieldConfig) {\r\n      return \"\";\r\n    }\r\n\r\n    if (fieldConfig.validator) {\r\n      return fieldConfig.validator(row[fieldName], row, fieldName);\r\n    }\r\n\r\n    return \"\";\r\n  }\r\n\r\n  /**\r\n   * 校验整行数据\r\n   *\r\n   * @param row 行数据\r\n   * @param config 表单配置\r\n   * @returns 校验结果对象，key为字段名，value为校验结果\r\n   */\r\n  private validateRow(\r\n    row: ArrayFormRow,\r\n    config: ArrayFormConfig\r\n  ): Record<string, ValidationResult> {\r\n    const results: Record<string, ValidationResult> = {};\r\n\r\n    config.fields.forEach((fieldConfig) => {\r\n      results[fieldConfig.name] = this.validateField(\r\n        row,\r\n        fieldConfig.name,\r\n        config\r\n      );\r\n    });\r\n\r\n    return results;\r\n  }\r\n\r\n  /**\r\n   * 校验整个数组\r\n   *\r\n   * @param data 数据数组\r\n   * @param config 表单配置\r\n   * @returns 校验结果对象，key为行的uid，value为该行的校验结果\r\n   */\r\n  private validateData(\r\n    data: ArrayFormRow[],\r\n    config: ArrayFormConfig\r\n  ): Record<string, Record<string, ValidationResult>> {\r\n    const results: Record<string, Record<string, ValidationResult>> = {};\r\n\r\n    data.forEach((row) => {\r\n      results[row.uid] = this.validateRow(row, config);\r\n    });\r\n\r\n    return results;\r\n  }\r\n\r\n  /**\r\n   * 注册表单到存储\r\n   * 如果表单已存在，则更新其配置\r\n   *\r\n   * @param formName 表单名称\r\n   * @param data 数据数组\r\n   * @param config 表单配置\r\n   */\r\n  registerForm(\r\n    formName: string,\r\n    data: ArrayFormRow[],\r\n    config: ArrayFormConfig\r\n  ): void {\r\n    this.formStore[formName] = {\r\n      data: this.initializeData(data),\r\n      config,\r\n      validationResults: {},\r\n    };\r\n    // 如果配置了自动更新，立即更新一次\r\n    this.autoUpdateArrayReference(formName);\r\n  }\r\n\r\n  /**\r\n   * 从存储中获取表单\r\n   *\r\n   * @param formName 表单名称\r\n   * @returns 表单存储项或undefined\r\n   */\r\n  getForm(formName: string): ArrayFormStoreItem | undefined {\r\n    return this.formStore[formName];\r\n  }\r\n\r\n  /**\r\n   * 向表单添加行\r\n   *\r\n   * @param formName 表单名称\r\n   * @param defaultValues 默认值\r\n   * @returns 新增的行数据或undefined\r\n   */\r\n  addRowToForm(\r\n    formName: string,\r\n    defaultValues?: Record<string, any>\r\n  ): ArrayFormRow | undefined {\r\n    const form = this.formStore[formName];\r\n    if (!form) {\r\n      return undefined;\r\n    }\r\n    const newRow = this.addRow(form.data, defaultValues);\r\n    // 自动更新外部数组引用\r\n    this.autoUpdateArrayReference(formName);\r\n    return newRow;\r\n  }\r\n\r\n  /**\r\n   * 校验表单\r\n   *\r\n   * @param formName 表单名称\r\n   * @returns 校验结果或undefined\r\n   */\r\n  validateForm(\r\n    formName: string\r\n  ): Record<string, Record<string, ValidationResult>> | undefined {\r\n    const form = this.formStore[formName];\r\n    if (!form) {\r\n      return undefined;\r\n    }\r\n    const results = this.validateData(form.data, form.config);\r\n    form.validationResults = results;\r\n    return results;\r\n  }\r\n\r\n  /**\r\n   * 开启指定行的编辑模式\r\n   *\r\n   * @param row 行数据\r\n   */\r\n  enableEdit(row: ArrayFormRow): void {\r\n    row.isEdit = true;\r\n  }\r\n\r\n  /**\r\n   * 关闭指定行的编辑模式\r\n   *\r\n   * @param row 行数据\r\n   */\r\n  disableEdit(row: ArrayFormRow): void {\r\n    row.isEdit = false;\r\n  }\r\n\r\n  /**\r\n   * 从表单中删除指定行\r\n   *\r\n   * @param formName 表单名称\r\n   * @param row 行的uid\r\n   * @returns 是否删除成功\r\n   */\r\n  deleteRowFromForm(formName: string, row: ArrayFormRow): boolean {\r\n    const form = this.formStore[formName];\r\n    if (!form) {\r\n      return false;\r\n    }\r\n    const index = form.data.findIndex((item) => item.uid === row.uid);\r\n    if (index === -1) {\r\n      return false;\r\n    }\r\n    form.data.splice(index, 1);\r\n    if (form.validationResults && form.validationResults[row.uid]) {\r\n      delete form.validationResults[row.uid];\r\n    }\r\n    // 自动更新外部数组引用\r\n    this.autoUpdateArrayReference(formName);\r\n    return true;\r\n  }\r\n\r\n  /**\r\n   * 校验指定行的指定字段并返回校验结果\r\n   * 实时执行校验，用于模板中的实时校验显示\r\n   *\r\n   * @param formName 表单名称\r\n   * @param row 行数据\r\n   * @param fieldName 字段名\r\n   * @returns 校验结果\r\n   */\r\n  validateFieldInRow(\r\n    formName: string,\r\n    row: ArrayFormRow,\r\n    fieldName: string\r\n  ): \"success\" | \"error\" {\r\n    const form = this.formStore[formName];\r\n    if (!form) {\r\n      return \"success\";\r\n    }\r\n\r\n    const fieldConfig = form.config.fields.find((f) => f.name === fieldName);\r\n    if (!fieldConfig) {\r\n      return \"success\";\r\n    }\r\n\r\n    let result: ValidationResult = \"\";\r\n    if (fieldConfig.validator) {\r\n      result = fieldConfig.validator(row[fieldName], row, fieldName);\r\n    }\r\n\r\n    // 更新校验结果存储\r\n    if (!form.validationResults) {\r\n      form.validationResults = {};\r\n    }\r\n    if (!form.validationResults[row.uid]) {\r\n      form.validationResults[row.uid] = {};\r\n    }\r\n    form.validationResults[row.uid][fieldName] = result;\r\n\r\n    return result ? \"error\" : \"success\";\r\n  }\r\n\r\n  /**\r\n   * 校验指定行的所有字段\r\n   *\r\n   * @param formName 表单名称\r\n   * @param row 行数据\r\n   * @returns 是否所有字段都通过校验\r\n   */\r\n  validateRowAllFields(formName: string, row: ArrayFormRow): boolean {\r\n    const form = this.formStore[formName];\r\n    if (!form) {\r\n      return true;\r\n    }\r\n\r\n    let hasError = false;\r\n\r\n    form.config.fields.forEach((fieldConfig) => {\r\n      const result = this.validateFieldInRow(formName, row, fieldConfig.name);\r\n      if (result === \"error\") {\r\n        hasError = true;\r\n      }\r\n    });\r\n\r\n    return !hasError;\r\n  }\r\n\r\n  /**\r\n   * 自动更新外部数组引用（如果配置了）\r\n   * 私有方法，在数据变化时自动调用\r\n   *\r\n   * @param formName 表单名称\r\n   */\r\n  private autoUpdateArrayReference(formName: string): void {\r\n    const form = this.formStore[formName];\r\n    if (!form || !form.config.targetObject || !form.config.arrayPropertyName) {\r\n      return;\r\n    }\r\n    const newArray = form.data ? [...form.data] : [];\r\n    // 更新目标对象的数组属性为新数组引用\r\n    (form.config.targetObject as any)[form.config.arrayPropertyName] = newArray;\r\n  }\r\n}\r\n"]}

package/esm2015/lib/plate-input/plate-input.component.js

@@ -152,4 +152,4 @@ PlateInputComponent.ctorParameters = () => [
     { type: ElementRef },
     { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [PLATE_PREFIX_LOAD_SERVICE,] }] }
 ];
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"plate-input.component.js","sourceRoot":"D:/projects/vps-front/Front/DasPMSWeb/projects/pro-table/src/","sources":["lib/plate-input/plate-input.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { Component, OnInit, OnDestroy, forwardRef, ChangeDetectorRef, ElementRef, Inject, Optional } from \"@angular/core\";\r\nimport { ControlValueAccessor, NG_VALUE_ACCESSOR } from \"@angular/forms\";\r\nimport { PLATE_PREFIX_LOAD_SERVICE, PlatePrefixLoadService, PlatePrefixOption } from \"../tokens\";\r\n\r\n@Component({\r\n  selector: \"app-plate-input\",\r\n  templateUrl: \"./plate-input.component.html\",\r\n  styleUrls: [\"./plate-input.component.less\"],\r\n  providers: [\r\n    {\r\n      provide: NG_VALUE_ACCESSOR,\r\n      useExisting: forwardRef(() => PlateInputComponent),\r\n      multi: true,\r\n    },\r\n  ],\r\n})\r\nexport class PlateInputComponent implements OnInit, OnDestroy, ControlValueAccessor {\r\n  nzPopoverVisible: boolean = false;\r\n  platePrefix: string = \"\";\r\n  plateSuffix: string = \"\";\r\n  platePrefixOptions: Array<PlatePrefixOption> = [];\r\n  disabled: boolean = false;\r\n  private onChange = (value: string) => {};\r\n  private onTouched = () => {};\r\n\r\n  private clickOutsideHandler?: (event: MouseEvent) => void;\r\n\r\n  constructor(\r\n    private cdr: ChangeDetectorRef,\r\n    private elementRef: ElementRef,\r\n    @Optional() @Inject(PLATE_PREFIX_LOAD_SERVICE) private platePrefixLoadService?: PlatePrefixLoadService\r\n  ) {}\r\n\r\n  ngOnInit(): void {\r\n    if (this.platePrefixLoadService) {\r\n      // 使用注入的全局服务加载车牌前缀选项\r\n      this.platePrefixLoadService\r\n        .loadPrefixOptions()\r\n        .then((data: Array<PlatePrefixOption>) => {\r\n          this.platePrefixOptions = data;\r\n        })\r\n        .catch(() => {\r\n          this.platePrefixOptions = [];\r\n        });\r\n    } else {\r\n      // 如果没有注入服务，则保持空数组\r\n      this.platePrefixOptions = [];\r\n    }\r\n  }\r\n\r\n  handlePlatePrefix(value: string): void {\r\n    this.platePrefix = value;\r\n    this.emitValue();\r\n    this.nzPopoverVisible = false;\r\n    this.removeClickOutsideListener();\r\n  }\r\n\r\n  writeValue(value: string): void {\r\n    if (value) {\r\n      this.platePrefix = value.split(\"\")[0];\r\n      this.plateSuffix = value\r\n        .split(\"\")\r\n        .filter((item, index) => index > 0)\r\n        .join(\"\");\r\n    } else {\r\n      this.platePrefix = \"\";\r\n      this.plateSuffix = \"\";\r\n    }\r\n  }\r\n\r\n  registerOnChange(fn: (value: string) => void): void {\r\n    this.onChange = fn;\r\n  }\r\n\r\n  registerOnTouched(fn: () => void): void {\r\n    this.onTouched = fn;\r\n  }\r\n\r\n  setDisabledState(isDisabled: boolean): void {\r\n    const previousDisabled = this.disabled;\r\n    this.disabled = isDisabled;\r\n    \r\n    // 如果禁用状态改变，关闭 popover 并移除监听器\r\n    if (previousDisabled !== isDisabled) {\r\n      this.nzPopoverVisible = false;\r\n      this.removeClickOutsideListener();\r\n      // 强制变更检测\r\n      this.cdr.detectChanges();\r\n    }\r\n  }\r\n\r\n  handlePrefixClick(event: Event): void {\r\n    if (this.disabled) {\r\n      event.preventDefault();\r\n      event.stopPropagation();\r\n      this.nzPopoverVisible = false;\r\n      return;\r\n    }\r\n    // 手动切换 popover 的显示/隐藏状态\r\n    this.nzPopoverVisible = !this.nzPopoverVisible;\r\n    \r\n    // 如果打开了 popover，添加文档点击监听器\r\n    if (this.nzPopoverVisible) {\r\n      setTimeout(() => {\r\n        this.attachClickOutsideListener();\r\n      }, 0);\r\n    } else {\r\n      this.removeClickOutsideListener();\r\n    }\r\n    \r\n    event.stopPropagation(); // 阻止事件冒泡\r\n  }\r\n\r\n  private attachClickOutsideListener(): void {\r\n    if (this.clickOutsideHandler) {\r\n      return;\r\n    }\r\n    \r\n    this.clickOutsideHandler = (event: MouseEvent) => {\r\n      const nativeElement = this.elementRef.nativeElement;\r\n      const target = event.target as HTMLElement;\r\n      \r\n      // 检查是否点击在 popover 内容区域内\r\n      const popoverContent = document.querySelector('.plate-input-popover');\r\n      const clickedInPopover = popoverContent && popoverContent.contains(target);\r\n      \r\n      // 检查是否点击在组件内部（前缀按钮）\r\n      const clickedInComponent = nativeElement.contains(target);\r\n      \r\n      // 如果点击既不在组件内部，也不在 popover 内容区域，则关闭 popover\r\n      if (!clickedInComponent && !clickedInPopover) {\r\n        this.nzPopoverVisible = false;\r\n        this.removeClickOutsideListener();\r\n        this.cdr.detectChanges();\r\n      }\r\n    };\r\n    \r\n    // 使用捕获阶段，确保在其他事件处理之前执行\r\n    document.addEventListener('click', this.clickOutsideHandler, true);\r\n  }\r\n\r\n  private removeClickOutsideListener(): void {\r\n    if (this.clickOutsideHandler) {\r\n      document.removeEventListener('click', this.clickOutsideHandler, true);\r\n      this.clickOutsideHandler = undefined;\r\n    }\r\n  }\r\n\r\n  ngOnDestroy(): void {\r\n    this.removeClickOutsideListener();\r\n  }\r\n\r\n  private emitValue(): void {\r\n    const fullPlate = this.platePrefix + this.plateSuffix;\r\n    this.onChange(fullPlate);\r\n  }\r\n\r\n  onBlur(): void {\r\n    this.onTouched();\r\n  }\r\n\r\n  handleAntdPlateSuffixBlur(event: any): void {\r\n    if (this.disabled) return;\r\n    const value = event.target.value.toUpperCase();\r\n    this.plateSuffix = value;\r\n    this.emitValue();\r\n  }\r\n}\r\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"plate-input.component.js","sourceRoot":"D:/projects/vps-front/Front/DasPMSWeb/lib/pro-table/src/","sources":["lib/plate-input/plate-input.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { Component, OnInit, OnDestroy, forwardRef, ChangeDetectorRef, ElementRef, Inject, Optional } from \"@angular/core\";\r\nimport { ControlValueAccessor, NG_VALUE_ACCESSOR } from \"@angular/forms\";\r\nimport { PLATE_PREFIX_LOAD_SERVICE, PlatePrefixLoadService, PlatePrefixOption } from \"../tokens\";\r\n\r\n@Component({\r\n  selector: \"app-plate-input\",\r\n  templateUrl: \"./plate-input.component.html\",\r\n  styleUrls: [\"./plate-input.component.less\"],\r\n  providers: [\r\n    {\r\n      provide: NG_VALUE_ACCESSOR,\r\n      useExisting: forwardRef(() => PlateInputComponent),\r\n      multi: true,\r\n    },\r\n  ],\r\n})\r\nexport class PlateInputComponent implements OnInit, OnDestroy, ControlValueAccessor {\r\n  nzPopoverVisible: boolean = false;\r\n  platePrefix: string = \"\";\r\n  plateSuffix: string = \"\";\r\n  platePrefixOptions: Array<PlatePrefixOption> = [];\r\n  disabled: boolean = false;\r\n  private onChange = (value: string) => {};\r\n  private onTouched = () => {};\r\n\r\n  private clickOutsideHandler?: (event: MouseEvent) => void;\r\n\r\n  constructor(\r\n    private cdr: ChangeDetectorRef,\r\n    private elementRef: ElementRef,\r\n    @Optional() @Inject(PLATE_PREFIX_LOAD_SERVICE) private platePrefixLoadService?: PlatePrefixLoadService\r\n  ) {}\r\n\r\n  ngOnInit(): void {\r\n    if (this.platePrefixLoadService) {\r\n      // 使用注入的全局服务加载车牌前缀选项\r\n      this.platePrefixLoadService\r\n        .loadPrefixOptions()\r\n        .then((data: Array<PlatePrefixOption>) => {\r\n          this.platePrefixOptions = data;\r\n        })\r\n        .catch(() => {\r\n          this.platePrefixOptions = [];\r\n        });\r\n    } else {\r\n      // 如果没有注入服务，则保持空数组\r\n      this.platePrefixOptions = [];\r\n    }\r\n  }\r\n\r\n  handlePlatePrefix(value: string): void {\r\n    this.platePrefix = value;\r\n    this.emitValue();\r\n    this.nzPopoverVisible = false;\r\n    this.removeClickOutsideListener();\r\n  }\r\n\r\n  writeValue(value: string): void {\r\n    if (value) {\r\n      this.platePrefix = value.split(\"\")[0];\r\n      this.plateSuffix = value\r\n        .split(\"\")\r\n        .filter((item, index) => index > 0)\r\n        .join(\"\");\r\n    } else {\r\n      this.platePrefix = \"\";\r\n      this.plateSuffix = \"\";\r\n    }\r\n  }\r\n\r\n  registerOnChange(fn: (value: string) => void): void {\r\n    this.onChange = fn;\r\n  }\r\n\r\n  registerOnTouched(fn: () => void): void {\r\n    this.onTouched = fn;\r\n  }\r\n\r\n  setDisabledState(isDisabled: boolean): void {\r\n    const previousDisabled = this.disabled;\r\n    this.disabled = isDisabled;\r\n    \r\n    // 如果禁用状态改变，关闭 popover 并移除监听器\r\n    if (previousDisabled !== isDisabled) {\r\n      this.nzPopoverVisible = false;\r\n      this.removeClickOutsideListener();\r\n      // 强制变更检测\r\n      this.cdr.detectChanges();\r\n    }\r\n  }\r\n\r\n  handlePrefixClick(event: Event): void {\r\n    if (this.disabled) {\r\n      event.preventDefault();\r\n      event.stopPropagation();\r\n      this.nzPopoverVisible = false;\r\n      return;\r\n    }\r\n    // 手动切换 popover 的显示/隐藏状态\r\n    this.nzPopoverVisible = !this.nzPopoverVisible;\r\n    \r\n    // 如果打开了 popover，添加文档点击监听器\r\n    if (this.nzPopoverVisible) {\r\n      setTimeout(() => {\r\n        this.attachClickOutsideListener();\r\n      }, 0);\r\n    } else {\r\n      this.removeClickOutsideListener();\r\n    }\r\n    \r\n    event.stopPropagation(); // 阻止事件冒泡\r\n  }\r\n\r\n  private attachClickOutsideListener(): void {\r\n    if (this.clickOutsideHandler) {\r\n      return;\r\n    }\r\n    \r\n    this.clickOutsideHandler = (event: MouseEvent) => {\r\n      const nativeElement = this.elementRef.nativeElement;\r\n      const target = event.target as HTMLElement;\r\n      \r\n      // 检查是否点击在 popover 内容区域内\r\n      const popoverContent = document.querySelector('.plate-input-popover');\r\n      const clickedInPopover = popoverContent && popoverContent.contains(target);\r\n      \r\n      // 检查是否点击在组件内部（前缀按钮）\r\n      const clickedInComponent = nativeElement.contains(target);\r\n      \r\n      // 如果点击既不在组件内部，也不在 popover 内容区域，则关闭 popover\r\n      if (!clickedInComponent && !clickedInPopover) {\r\n        this.nzPopoverVisible = false;\r\n        this.removeClickOutsideListener();\r\n        this.cdr.detectChanges();\r\n      }\r\n    };\r\n    \r\n    // 使用捕获阶段，确保在其他事件处理之前执行\r\n    document.addEventListener('click', this.clickOutsideHandler, true);\r\n  }\r\n\r\n  private removeClickOutsideListener(): void {\r\n    if (this.clickOutsideHandler) {\r\n      document.removeEventListener('click', this.clickOutsideHandler, true);\r\n      this.clickOutsideHandler = undefined;\r\n    }\r\n  }\r\n\r\n  ngOnDestroy(): void {\r\n    this.removeClickOutsideListener();\r\n  }\r\n\r\n  private emitValue(): void {\r\n    const fullPlate = this.platePrefix + this.plateSuffix;\r\n    this.onChange(fullPlate);\r\n  }\r\n\r\n  onBlur(): void {\r\n    this.onTouched();\r\n  }\r\n\r\n  handleAntdPlateSuffixBlur(event: any): void {\r\n    if (this.disabled) return;\r\n    const value = event.target.value.toUpperCase();\r\n    this.plateSuffix = value;\r\n    this.emitValue();\r\n  }\r\n}\r\n"]}

package/esm2015/lib/plate-input/plate-input.module.js

@@ -23,4 +23,4 @@ PlateInputModule.decorators = [
                 exports: [PlateInputComponent],
             },] }
 ];
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/plate-input/plate-prefix-load.service.js

@@ -38,4 +38,4 @@ DefaultPlatePrefixLoadService.decorators = [
 DefaultPlatePrefixLoadService.ctorParameters = () => [
     { type: HttpClient }
 ];
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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