@alauda-fe/dynamic-plugin-shared 0.0.1-alpha.0

package/esm2022/form/errors-mapper/errors-mapper.directive.mjs

@@ -0,0 +1,109 @@
+import { __decorate, __metadata } from "tslib";
+import { ComponentPortal, DomPortalOutlet } from '@angular/cdk/portal';
+import { ApplicationRef, ChangeDetectionStrategy, ChangeDetectorRef, Component, ComponentFactoryResolver, Directive, Injector, Input, Optional, Self, } from '@angular/core';
+import { FormGroupDirective, NgControl, NgForm } from '@angular/forms';
+import { Observable, Subject, merge, of, debounceTime, map, switchMap, takeUntil, } from 'rxjs';
+import { ObservableInput } from '../../utils';
+import { BaseErrorsMapper } from './base-errors-mapper';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/forms";
+export class ErrorsMapperDirective extends BaseErrorsMapper {
+    constructor(injector, cdr, cfr, appRef, control, ngForm, formGroup) {
+        super(injector);
+        this.injector = injector;
+        this.cdr = cdr;
+        this.cfr = cfr;
+        this.appRef = appRef;
+        this.control = control;
+        this.ngForm = ngForm;
+        this.formGroup = formGroup;
+        this.destroy$ = new Subject();
+    }
+    ngAfterViewInit() {
+        if (!this.control) {
+            throw new Error('Errors mapper is not properly configured. No valid control is found.');
+        }
+        this.initPortal();
+        const statusChange = [this.control.statusChanges];
+        if (this.ngForm) {
+            statusChange.push(this.ngForm.ngSubmit);
+        }
+        if (this.formGroup) {
+            statusChange.push(this.formGroup.ngSubmit);
+        }
+        this.aclErrorsMapperDisabled$
+            .pipe(switchMap(isDisable => isDisable
+            ? of(null)
+            : merge(...statusChange, this.translate.locale$).pipe(debounceTime(50), map(() => this.getErrorMessage(this.control.errors, this.aclErrorsMapper || {}, this.aclErrorsMapperFn, this.aclErrorsMapperControlName)))), takeUntil(this.destroy$))
+            .subscribe(content => {
+            this.updateContent(content);
+            this.cdr.markForCheck();
+        });
+    }
+    updateContent(content) {
+        if (!content) {
+            if (this.portalHost.hasAttached()) {
+                this.portalHost.detach();
+            }
+            return;
+        }
+        if (!this.portalHost.hasAttached()) {
+            this.portalAttach = this.portalHost.attach(this.portal).instance;
+        }
+        this.portalAttach.data = content;
+        this.portalAttach.cdr.markForCheck();
+    }
+    initPortal() {
+        this.portalHost = new DomPortalOutlet(this.aclErrorsMapperOutlet, this.cfr, this.appRef, this.injector);
+        this.portal = new ComponentPortal(TextComponent);
+    }
+    ngOnDestroy() {
+        this.destroy$.next();
+        this.portalHost.dispose();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: ErrorsMapperDirective, deps: [{ token: i0.Injector }, { token: i0.ChangeDetectorRef }, { token: i0.ComponentFactoryResolver }, { token: i0.ApplicationRef }, { token: i1.NgControl, self: true }, { token: i1.NgForm, optional: true }, { token: i1.FormGroupDirective, optional: true }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.1.1", type: ErrorsMapperDirective, isStandalone: true, selector: "[aclErrorsMapper]", inputs: { aclErrorsMapper: "aclErrorsMapper", aclErrorsMapperFn: "aclErrorsMapperFn", aclErrorsMapperDisabled: "aclErrorsMapperDisabled", aclErrorsMapperOutlet: "aclErrorsMapperOutlet", aclErrorsMapperControlName: "aclErrorsMapperControlName" }, usesInheritance: true, ngImport: i0 }); }
+}
+__decorate([
+    ObservableInput(),
+    __metadata("design:type", Observable)
+], ErrorsMapperDirective.prototype, "aclErrorsMapperDisabled$", void 0);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: ErrorsMapperDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[aclErrorsMapper]',
+                    standalone: true,
+                }]
+        }], ctorParameters: () => [{ type: i0.Injector }, { type: i0.ChangeDetectorRef }, { type: i0.ComponentFactoryResolver }, { type: i0.ApplicationRef }, { type: i1.NgControl, decorators: [{
+                    type: Self
+                }] }, { type: i1.NgForm, decorators: [{
+                    type: Optional
+                }] }, { type: i1.FormGroupDirective, decorators: [{
+                    type: Optional
+                }] }], propDecorators: { aclErrorsMapper: [{
+                type: Input
+            }], aclErrorsMapperFn: [{
+                type: Input
+            }], aclErrorsMapperDisabled: [{
+                type: Input
+            }], aclErrorsMapperDisabled$: [], aclErrorsMapperOutlet: [{
+                type: Input
+            }], aclErrorsMapperControlName: [{
+                type: Input
+            }] } });
+class TextComponent {
+    constructor(cdr) {
+        this.cdr = cdr;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: TextComponent, deps: [{ token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.1.1", type: TextComponent, isStandalone: true, selector: "ng-component", ngImport: i0, template: ` {{ data }} `, isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: TextComponent, decorators: [{
+            type: Component,
+            args: [{
+                    template: ` {{ data }} `,
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    standalone: true,
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"errors-mapper.directive.js","sourceRoot":"","sources":["../../../../../../libs/dynamic-plugin-shared/src/form/errors-mapper/errors-mapper.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import { ComponentPortal, DomPortalOutlet, Portal } from '@angular/cdk/portal';\nimport {\n  AfterViewInit,\n  ApplicationRef,\n  ChangeDetectionStrategy,\n  ChangeDetectorRef,\n  Component,\n  ComponentFactoryResolver,\n  Directive,\n  Injector,\n  Input,\n  OnDestroy,\n  Optional,\n  Self,\n} from '@angular/core';\nimport { FormGroupDirective, NgControl, NgForm } from '@angular/forms';\nimport {\n  Observable,\n  Subject,\n  merge,\n  of,\n  debounceTime,\n  map,\n  switchMap,\n  takeUntil,\n} from 'rxjs';\n\nimport { StringMap } from '../../types';\nimport { ObservableInput } from '../../utils';\n\nimport { BaseErrorsMapper } from './base-errors-mapper';\nimport { ErrorsMapperFn } from './types';\n\n@Directive({\n  selector: '[aclErrorsMapper]',\n  standalone: true,\n})\nexport class ErrorsMapperDirective\n  extends BaseErrorsMapper\n  implements AfterViewInit, OnDestroy\n{\n  @Input()\n  aclErrorsMapper: StringMap | '';\n\n  @Input()\n  aclErrorsMapperFn: ErrorsMapperFn;\n\n  @Input()\n  aclErrorsMapperDisabled: boolean;\n\n  /**\n   * disable errors mapper\n   */\n  @ObservableInput()\n  aclErrorsMapperDisabled$: Observable<boolean>;\n\n  /**\n   * specify outlet, consider this other than specific control entity to make sure di can always get ngForm\n   */\n  @Input()\n  aclErrorsMapperOutlet: Element;\n\n  @Input()\n  aclErrorsMapperControlName: string;\n\n  private portal: Portal<any>;\n  private portalHost: DomPortalOutlet;\n  private portalAttach: TextComponent;\n  private readonly destroy$ = new Subject<void>();\n\n  constructor(\n    public injector: Injector,\n    private readonly cdr: ChangeDetectorRef,\n    private readonly cfr: ComponentFactoryResolver,\n    private readonly appRef: ApplicationRef,\n    @Self() private readonly control: NgControl,\n    @Optional() private readonly ngForm: NgForm,\n    @Optional()\n    private readonly formGroup: FormGroupDirective,\n  ) {\n    super(injector);\n  }\n\n  ngAfterViewInit() {\n    if (!this.control) {\n      throw new Error(\n        'Errors mapper is not properly configured. No valid control is found.',\n      );\n    }\n    this.initPortal();\n    const statusChange = [this.control.statusChanges];\n\n    if (this.ngForm) {\n      statusChange.push(this.ngForm.ngSubmit);\n    }\n    if (this.formGroup) {\n      statusChange.push(this.formGroup.ngSubmit);\n    }\n\n    this.aclErrorsMapperDisabled$\n      .pipe(\n        switchMap(isDisable =>\n          isDisable\n            ? of(null)\n            : merge(...statusChange, this.translate.locale$).pipe(\n                debounceTime(50),\n                map(() =>\n                  this.getErrorMessage(\n                    this.control.errors,\n                    this.aclErrorsMapper || {},\n                    this.aclErrorsMapperFn,\n                    this.aclErrorsMapperControlName,\n                  ),\n                ),\n              ),\n        ),\n        takeUntil(this.destroy$),\n      )\n      .subscribe(content => {\n        this.updateContent(content);\n        this.cdr.markForCheck();\n      });\n  }\n\n  updateContent(content: string) {\n    if (!content) {\n      if (this.portalHost.hasAttached()) {\n        this.portalHost.detach();\n      }\n      return;\n    }\n    if (!this.portalHost.hasAttached()) {\n      this.portalAttach = this.portalHost.attach(this.portal).instance;\n    }\n    this.portalAttach.data = content;\n    this.portalAttach.cdr.markForCheck();\n  }\n\n  initPortal() {\n    this.portalHost = new DomPortalOutlet(\n      this.aclErrorsMapperOutlet,\n      this.cfr,\n      this.appRef,\n      this.injector,\n    );\n    this.portal = new ComponentPortal(TextComponent);\n  }\n\n  ngOnDestroy() {\n    this.destroy$.next();\n    this.portalHost.dispose();\n  }\n}\n\n@Component({\n  template: ` {{ data }} `,\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  standalone: true,\n})\nclass TextComponent {\n  data: string;\n  constructor(public cdr: ChangeDetectorRef) {}\n}\n"]}

package/esm2022/form/errors-mapper/index.mjs

@@ -0,0 +1,10 @@
+import { ErrorsMapperComponent } from './errors-mapper-component/component';
+import { ErrorsMapperDirective } from './errors-mapper.directive';
+export * from './errors-mapper-component/component';
+export * from './errors-mapper.directive';
+export * from './types';
+export const ERRORS_MAPPER_MODULE = [
+    ErrorsMapperComponent,
+    ErrorsMapperDirective,
+];
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9saWJzL2R5bmFtaWMtcGx1Z2luLXNoYXJlZC9zcmMvZm9ybS9lcnJvcnMtbWFwcGVyL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxxQkFBcUIsRUFBRSxNQUFNLHFDQUFxQyxDQUFDO0FBQzVFLE9BQU8sRUFBRSxxQkFBcUIsRUFBRSxNQUFNLDJCQUEyQixDQUFDO0FBRWxFLGNBQWMscUNBQXFDLENBQUM7QUFDcEQsY0FBYywyQkFBMkIsQ0FBQztBQUMxQyxjQUFjLFNBQVMsQ0FBQztBQUV4QixNQUFNLENBQUMsTUFBTSxvQkFBb0IsR0FBRztJQUNsQyxxQkFBcUI7SUFDckIscUJBQXFCO0NBQ2IsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEVycm9yc01hcHBlckNvbXBvbmVudCB9IGZyb20gJy4vZXJyb3JzLW1hcHBlci1jb21wb25lbnQvY29tcG9uZW50JztcbmltcG9ydCB7IEVycm9yc01hcHBlckRpcmVjdGl2ZSB9IGZyb20gJy4vZXJyb3JzLW1hcHBlci5kaXJlY3RpdmUnO1xuXG5leHBvcnQgKiBmcm9tICcuL2Vycm9ycy1tYXBwZXItY29tcG9uZW50L2NvbXBvbmVudCc7XG5leHBvcnQgKiBmcm9tICcuL2Vycm9ycy1tYXBwZXIuZGlyZWN0aXZlJztcbmV4cG9ydCAqIGZyb20gJy4vdHlwZXMnO1xuXG5leHBvcnQgY29uc3QgRVJST1JTX01BUFBFUl9NT0RVTEUgPSBbXG4gIEVycm9yc01hcHBlckNvbXBvbmVudCxcbiAgRXJyb3JzTWFwcGVyRGlyZWN0aXZlLFxuXSBhcyBjb25zdDtcbiJdfQ==

package/esm2022/form/errors-mapper/types.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9saWJzL2R5bmFtaWMtcGx1Z2luLXNoYXJlZC9zcmMvZm9ybS9lcnJvcnMtbWFwcGVyL3R5cGVzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBTdHJpbmdNYXAgfSBmcm9tICcuLi8uLi90eXBlcyc7XG5cbi8qKlxuICogRGVmaW5lcyBob3cgYSBlcnJvciBvYmplY3QgKHZhbGlkYXRvciBrZXksIGVycm9yIG9iamVjdCwgdGhlIGNvbnRyb2wgb2JqZWN0KSBzaG91bGQgYmUgbWFwcGVkIHRvIHN0cmluZy5cbiAqL1xuZXhwb3J0IGludGVyZmFjZSBFcnJvck1hcHBlckludGVyZmFjZSB7XG4gIC8qKlxuICAgKiBNYXBzIGFuIGVycm9yIHRvIGEgc3RyaW5nLlxuICAgKiBAcGFyYW0ge3N0cmluZ30ga2V5IHRoZSBlcnJvciBrZXkuIGkuZS4sIHJlcXVpcmVkLCBldGNcbiAgICogQHBhcmFtIGVycm9yIHRoZSBlcnJvciBvYmplY3RcbiAgICogQHBhcmFtIGNvbnRyb2wgY29udHJvbCBPYmplY3QgKEFic3RyYWN0Q29udHJvbCBmb3IgQW5ndWxhciwgTmdNb2RlbCBmb3IgQW5ndWxhckpTKVxuICAgKiBAcmV0dXJucyB7c3RyaW5nfVxuICAgKi9cbiAgbWFwKGtleTogc3RyaW5nLCBlcnJvcj86IHVua25vd24sIGNvbnRyb2w/OiB1bmtub3duKTogc3RyaW5nO1xufVxuXG5leHBvcnQgdHlwZSBFcnJvcnNNYXBwZXJGbiA9IChlcnJvcjogUmVjb3JkPHN0cmluZywgdW5rbm93bj4pID0+IHN0cmluZztcblxuZXhwb3J0IHR5cGUgRXJyb3JNYXBwZXIgPSBFcnJvck1hcHBlckludGVyZmFjZSB8IFN0cmluZ01hcDtcbiJdfQ==

package/esm2022/form/index.mjs

@@ -0,0 +1,6 @@
+export * from './validators';
+export * from './errors-mapper';
+export { genControlDepsMap } from './utils';
+export * from './base-form-container';
+export * from './base-nested-form-control';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9saWJzL2R5bmFtaWMtcGx1Z2luLXNoYXJlZC9zcmMvZm9ybS9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLGNBQWMsQ0FBQztBQUM3QixjQUFjLGlCQUFpQixDQUFDO0FBQ2hDLE9BQU8sRUFBRSxpQkFBaUIsRUFBRSxNQUFNLFNBQVMsQ0FBQztBQUU1QyxjQUFjLHVCQUF1QixDQUFDO0FBQ3RDLGNBQWMsNEJBQTRCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL3ZhbGlkYXRvcnMnO1xuZXhwb3J0ICogZnJvbSAnLi9lcnJvcnMtbWFwcGVyJztcbmV4cG9ydCB7IGdlbkNvbnRyb2xEZXBzTWFwIH0gZnJvbSAnLi91dGlscyc7XG5cbmV4cG9ydCAqIGZyb20gJy4vYmFzZS1mb3JtLWNvbnRhaW5lcic7XG5leHBvcnQgKiBmcm9tICcuL2Jhc2UtbmVzdGVkLWZvcm0tY29udHJvbCc7XG4iXX0=

package/esm2022/form/utils.mjs

@@ -0,0 +1,61 @@
+import { uniq } from 'lodash-es';
+import { distinctUntilChanged, map, merge, startWith, takeUntil, } from 'rxjs';
+/**
+ * @description
+ * 创建集群中存在大量的 control 依赖的情形，同时，由于业务特殊性，在 ipv4,ipv6 时要对表单控件进行不同外观的展示，因此控件的 disabled 变得很复杂
+ * 如果是在 ts 里通过 valueChanges 写：每个影响源都要写自己的 subscription，且某个 control 可能会收到多个其他 control 影响，届时逻辑组织会复杂很多,
+ * 如果是在模板里通过 aluControlDisabled 去写，可能会存在多个 control 要重复同一套逻辑，这点在创建集群中很常见，因此提供了如下方案，可以以声明式写法去描述依赖关系
+ *
+ * @usageNotes
+ * For example, for the following `FormGroup`:
+ * ```
+ * [
+ {
+ source: 'joinCIDR',
+ deps: ['networkType'],
+ isEnable: networkType => networkType === 'kube-ovn',
+ },
+ {
+ source: 'gatewayIPv6',
+ deps: ['networkType', 'transmitType', 'ipv6DualStack'],
+ isEnable: (networkType, transmitType, ipv6DualStack: boolean) =>
+ networkType === 'kube-ovn' &&
+ transmitType === 'underlay' &&
+ ipv6DualStack,
+ },
+ {
+ source: ['clusterCIDRIPv6', 'serviceCIDRIPv6'],
+ deps: ['ipv6DualStack'],
+ isEnable: (ipv6DualStack: boolean) => ipv6DualStack,
+ },
+ ]
+ * ```
+ */
+export function genControlDepsMap(context, rules, destroy$) {
+    const normRules = rules.flatMap(r => Array.isArray(r.source) ? r.source.map(s => ({ ...r, source: s })) : r);
+    const depPaths = uniq(normRules.flatMap(r => r.deps));
+    const depRuleMap = normRules.reduce((acc, rule) => {
+        for (const dep of rule.deps) {
+            if (!acc[dep]) {
+                acc[dep] = new Set();
+            }
+            acc[dep].add(rule.source);
+        }
+        return acc;
+    }, {});
+    // 每一次 deps 中的 valueChange 都有可能是一次 trigger
+    merge(...depPaths.map(p => context.get(p).valueChanges.pipe(startWith(context.get(p).value), distinctUntilChanged(), map(value => ({
+        key: p,
+        value,
+    })))))
+        .pipe(takeUntil(destroy$))
+        .subscribe(result => {
+        depRuleMap[result.key].forEach(source => {
+            const rules = normRules.filter(r => r.source === source);
+            const enable = rules.every(rule => rule.isEnable(...rule.deps.map(dep => context.get(dep).value)));
+            context
+                .get(source)[enable ? 'enable' : 'disable']({ emitEvent: false }); // emitEvent: false 会防止主动将本控件设为dirty
+        });
+    });
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXRpbHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9saWJzL2R5bmFtaWMtcGx1Z2luLXNoYXJlZC9zcmMvZm9ybS91dGlscy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxPQUFPLEVBQUUsSUFBSSxFQUFFLE1BQU0sV0FBVyxDQUFDO0FBQ2pDLE9BQU8sRUFDTCxvQkFBb0IsRUFDcEIsR0FBRyxFQUNILEtBQUssRUFFTCxTQUFTLEVBQ1QsU0FBUyxHQUNWLE1BQU0sTUFBTSxDQUFDO0FBUWQ7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztHQThCRztBQUNILE1BQU0sVUFBVSxpQkFBaUIsQ0FDL0IsT0FBa0IsRUFDbEIsS0FBcUMsRUFDckMsUUFBNkI7SUFFN0IsTUFBTSxTQUFTLEdBQUcsS0FBSyxDQUFDLE9BQU8sQ0FBQyxDQUFDLENBQUMsRUFBRSxDQUNsQyxLQUFLLENBQUMsT0FBTyxDQUFDLENBQUMsQ0FBQyxNQUFNLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDLE1BQU0sQ0FBQyxHQUFHLENBQUMsQ0FBQyxDQUFDLEVBQUUsQ0FBQyxDQUFDLEVBQUUsR0FBRyxDQUFDLEVBQUUsTUFBTSxFQUFFLENBQUMsRUFBRSxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUNoRCxDQUFDO0lBQ3pCLE1BQU0sUUFBUSxHQUFHLElBQUksQ0FBQyxTQUFTLENBQUMsT0FBTyxDQUFDLENBQUMsQ0FBQyxFQUFFLENBQUMsQ0FBQyxDQUFDLElBQUksQ0FBQyxDQUFDLENBQUM7SUFDdEQsTUFBTSxVQUFVLEdBQUcsU0FBUyxDQUFDLE1BQU0sQ0FDakMsQ0FBQyxHQUFHLEVBQUUsSUFBSSxFQUFFLEVBQUU7UUFDWixLQUFLLE1BQU0sR0FBRyxJQUFJLElBQUksQ0FBQyxJQUFJLEVBQUUsQ0FBQztZQUM1QixJQUFJLENBQUMsR0FBRyxDQUFDLEdBQUcsQ0FBQyxFQUFFLENBQUM7Z0JBQ2QsR0FBRyxDQUFDLEdBQUcsQ0FBQyxHQUFHLElBQUksR0FBRyxFQUFFLENBQUM7WUFDdkIsQ0FBQztZQUNELEdBQUcsQ0FBQyxHQUFHLENBQUMsQ0FBQyxHQUFHLENBQUMsSUFBSSxDQUFDLE1BQU0sQ0FBQyxDQUFDO1FBQzVCLENBQUM7UUFDRCxPQUFPLEdBQUcsQ0FBQztJQUNiLENBQUMsRUFDRCxFQUFrQyxDQUNuQyxDQUFDO0lBQ0YsMENBQTBDO0lBQzFDLEtBQUssQ0FDSCxHQUFHLFFBQVEsQ0FBQyxHQUFHLENBQUMsQ0FBQyxDQUFDLEVBQUUsQ0FDbEIsT0FBTyxDQUFDLEdBQUcsQ0FBQyxDQUFDLENBQUMsQ0FBQyxZQUFZLENBQUMsSUFBSSxDQUM5QixTQUFTLENBQUMsT0FBTyxDQUFDLEdBQUcsQ0FBQyxDQUFDLENBQUMsQ0FBQyxLQUFLLENBQUMsRUFDL0Isb0JBQW9CLEVBQUUsRUFDdEIsR0FBRyxDQUFDLEtBQUssQ0FBQyxFQUFFLENBQUMsQ0FBQztRQUNaLEdBQUcsRUFBRSxDQUFDO1FBQ04sS0FBSztLQUNOLENBQUMsQ0FBQyxDQUNKLENBQ0YsQ0FDRjtTQUNFLElBQUksQ0FBQyxTQUFTLENBQUMsUUFBUSxDQUFDLENBQUM7U0FDekIsU0FBUyxDQUFDLE1BQU0sQ0FBQyxFQUFFO1FBQ2xCLFVBQVUsQ0FBQyxNQUFNLENBQUMsR0FBRyxDQUFDLENBQUMsT0FBTyxDQUFDLE1BQU0sQ0FBQyxFQUFFO1lBQ3RDLE1BQU0sS0FBSyxHQUFHLFNBQVMsQ0FBQyxNQUFNLENBQUMsQ0FBQyxDQUFDLEVBQUUsQ0FBQyxDQUFDLENBQUMsTUFBTSxLQUFLLE1BQU0sQ0FBQyxDQUFDO1lBQ3pELE1BQU0sTUFBTSxHQUFHLEtBQUssQ0FBQyxLQUFLLENBQUMsSUFBSSxDQUFDLEVBQUUsQ0FDaEMsSUFBSSxDQUFDLFFBQVEsQ0FBQyxHQUFHLElBQUksQ0FBQyxJQUFJLENBQUMsR0FBRyxDQUFDLEdBQUcsQ0FBQyxFQUFFLENBQUMsT0FBTyxDQUFDLEdBQUcsQ0FBQyxHQUFHLENBQUMsQ0FBQyxLQUFLLENBQUMsQ0FBQyxDQUMvRCxDQUFDO1lBQ0YsT0FBTztpQkFDSixHQUFHLENBQUMsTUFBTSxDQUFDLENBQ1gsTUFBTSxDQUFDLENBQUMsQ0FBQyxRQUFRLENBQUMsQ0FBQyxDQUFDLFNBQVMsQ0FBQyxDQUFDLEVBQUUsU0FBUyxFQUFFLEtBQUssRUFBRSxDQUFDLENBQUMsQ0FBQyxvQ0FBb0M7UUFDL0YsQ0FBQyxDQUFDLENBQUM7SUFDTCxDQUFDLENBQUMsQ0FBQztBQUNQLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBGb3JtR3JvdXAgfSBmcm9tICdAYW5ndWxhci9mb3Jtcyc7XG5pbXBvcnQgeyB1bmlxIH0gZnJvbSAnbG9kYXNoLWVzJztcbmltcG9ydCB7XG4gIGRpc3RpbmN0VW50aWxDaGFuZ2VkLFxuICBtYXAsXG4gIG1lcmdlLFxuICBPYnNlcnZhYmxlLFxuICBzdGFydFdpdGgsXG4gIHRha2VVbnRpbCxcbn0gZnJvbSAncnhqcyc7XG5cbmludGVyZmFjZSBSdWxlPFQ+IHtcbiAgc291cmNlOiBUO1xuICBkZXBzOiBzdHJpbmdbXTtcbiAgaXNFbmFibGU6ICguLi5kZXBzOiB1bmtub3duW10pID0+IGJvb2xlYW47XG59XG5cbi8qKlxuICogQGRlc2NyaXB0aW9uXG4gKiDliJvlu7rpm4bnvqTkuK3lrZjlnKjlpKfph4/nmoQgY29udHJvbCDkvp3otZbnmoTmg4XlvaLvvIzlkIzml7bvvIznlLHkuo7kuJrliqHnibnmrormgKfvvIzlnKggaXB2NCxpcHY2IOaXtuimgeWvueihqOWNleaOp+S7tui/m+ihjOS4jeWQjOWkluingueahOWxleekuu+8jOWboOatpOaOp+S7tueahCBkaXNhYmxlZCDlj5jlvpflvojlpI3mnYJcbiAqIOWmguaenOaYr+WcqCB0cyDph4zpgJrov4cgdmFsdWVDaGFuZ2VzIOWGme+8muavj+S4quW9seWTjea6kOmDveimgeWGmeiHquW3seeahCBzdWJzY3JpcHRpb27vvIzkuJTmn5DkuKogY29udHJvbCDlj6/og73kvJrmlLbliLDlpJrkuKrlhbbku5YgY29udHJvbCDlvbHlk43vvIzlsYrml7bpgLvovpHnu4Tnu4fkvJrlpI3mnYLlvojlpJosXG4gKiDlpoLmnpzmmK/lnKjmqKHmnb/ph4zpgJrov4cgYWx1Q29udHJvbERpc2FibGVkIOWOu+WGme+8jOWPr+iDveS8muWtmOWcqOWkmuS4qiBjb250cm9sIOimgemHjeWkjeWQjOS4gOWll+mAu+i+ke+8jOi/meeCueWcqOWIm+W7uumbhue+pOS4reW+iOW4uOinge+8jOWboOatpOaPkOS+m+S6huWmguS4i+aWueahiO+8jOWPr+S7peS7peWjsOaYjuW8j+WGmeazleWOu+aPj+i/sOS+nei1luWFs+ezu1xuICpcbiAqIEB1c2FnZU5vdGVzXG4gKiBGb3IgZXhhbXBsZSwgZm9yIHRoZSBmb2xsb3dpbmcgYEZvcm1Hcm91cGA6XG4gKiBgYGBcbiAqIFtcbiB7XG4gc291cmNlOiAnam9pbkNJRFInLFxuIGRlcHM6IFsnbmV0d29ya1R5cGUnXSxcbiBpc0VuYWJsZTogbmV0d29ya1R5cGUgPT4gbmV0d29ya1R5cGUgPT09ICdrdWJlLW92bicsXG4gfSxcbiB7XG4gc291cmNlOiAnZ2F0ZXdheUlQdjYnLFxuIGRlcHM6IFsnbmV0d29ya1R5cGUnLCAndHJhbnNtaXRUeXBlJywgJ2lwdjZEdWFsU3RhY2snXSxcbiBpc0VuYWJsZTogKG5ldHdvcmtUeXBlLCB0cmFuc21pdFR5cGUsIGlwdjZEdWFsU3RhY2s6IGJvb2xlYW4pID0+XG4gbmV0d29ya1R5cGUgPT09ICdrdWJlLW92bicgJiZcbiB0cmFuc21pdFR5cGUgPT09ICd1bmRlcmxheScgJiZcbiBpcHY2RHVhbFN0YWNrLFxuIH0sXG4ge1xuIHNvdXJjZTogWydjbHVzdGVyQ0lEUklQdjYnLCAnc2VydmljZUNJRFJJUHY2J10sXG4gZGVwczogWydpcHY2RHVhbFN0YWNrJ10sXG4gaXNFbmFibGU6IChpcHY2RHVhbFN0YWNrOiBib29sZWFuKSA9PiBpcHY2RHVhbFN0YWNrLFxuIH0sXG4gXVxuICogYGBgXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBnZW5Db250cm9sRGVwc01hcChcbiAgY29udGV4dDogRm9ybUdyb3VwLFxuICBydWxlczogQXJyYXk8UnVsZTxzdHJpbmcgfCBzdHJpbmdbXT4+LFxuICBkZXN0cm95JDogT2JzZXJ2YWJsZTx1bmtub3duPixcbikge1xuICBjb25zdCBub3JtUnVsZXMgPSBydWxlcy5mbGF0TWFwKHIgPT5cbiAgICBBcnJheS5pc0FycmF5KHIuc291cmNlKSA/IHIuc291cmNlLm1hcChzID0+ICh7IC4uLnIsIHNvdXJjZTogcyB9KSkgOiByLFxuICApIGFzIEFycmF5PFJ1bGU8c3RyaW5nPj47XG4gIGNvbnN0IGRlcFBhdGhzID0gdW5pcShub3JtUnVsZXMuZmxhdE1hcChyID0+IHIuZGVwcykpO1xuICBjb25zdCBkZXBSdWxlTWFwID0gbm9ybVJ1bGVzLnJlZHVjZShcbiAgICAoYWNjLCBydWxlKSA9PiB7XG4gICAgICBmb3IgKGNvbnN0IGRlcCBvZiBydWxlLmRlcHMpIHtcbiAgICAgICAgaWYgKCFhY2NbZGVwXSkge1xuICAgICAgICAgIGFjY1tkZXBdID0gbmV3IFNldCgpO1xuICAgICAgICB9XG4gICAgICAgIGFjY1tkZXBdLmFkZChydWxlLnNvdXJjZSk7XG4gICAgICB9XG4gICAgICByZXR1cm4gYWNjO1xuICAgIH0sXG4gICAge30gYXMgeyBbeDogc3RyaW5nXTogU2V0PHN0cmluZz4gfSxcbiAgKTtcbiAgLy8g5q+P5LiA5qyhIGRlcHMg5Lit55qEIHZhbHVlQ2hhbmdlIOmDveacieWPr+iDveaYr+S4gOasoSB0cmlnZ2VyXG4gIG1lcmdlKFxuICAgIC4uLmRlcFBhdGhzLm1hcChwID0+XG4gICAgICBjb250ZXh0LmdldChwKS52YWx1ZUNoYW5nZXMucGlwZShcbiAgICAgICAgc3RhcnRXaXRoKGNvbnRleHQuZ2V0KHApLnZhbHVlKSxcbiAgICAgICAgZGlzdGluY3RVbnRpbENoYW5nZWQoKSxcbiAgICAgICAgbWFwKHZhbHVlID0+ICh7XG4gICAgICAgICAga2V5OiBwLFxuICAgICAgICAgIHZhbHVlLFxuICAgICAgICB9KSksXG4gICAgICApLFxuICAgICksXG4gIClcbiAgICAucGlwZSh0YWtlVW50aWwoZGVzdHJveSQpKVxuICAgIC5zdWJzY3JpYmUocmVzdWx0ID0+IHtcbiAgICAgIGRlcFJ1bGVNYXBbcmVzdWx0LmtleV0uZm9yRWFjaChzb3VyY2UgPT4ge1xuICAgICAgICBjb25zdCBydWxlcyA9IG5vcm1SdWxlcy5maWx0ZXIociA9PiByLnNvdXJjZSA9PT0gc291cmNlKTtcbiAgICAgICAgY29uc3QgZW5hYmxlID0gcnVsZXMuZXZlcnkocnVsZSA9PlxuICAgICAgICAgIHJ1bGUuaXNFbmFibGUoLi4ucnVsZS5kZXBzLm1hcChkZXAgPT4gY29udGV4dC5nZXQoZGVwKS52YWx1ZSkpLFxuICAgICAgICApO1xuICAgICAgICBjb250ZXh0XG4gICAgICAgICAgLmdldChzb3VyY2UpXG4gICAgICAgICAgW2VuYWJsZSA/ICdlbmFibGUnIDogJ2Rpc2FibGUnXSh7IGVtaXRFdmVudDogZmFsc2UgfSk7IC8vIGVtaXRFdmVudDogZmFsc2Ug5Lya6Ziy5q2i5Li75Yqo5bCG5pys5o6n5Lu26K6+5Li6ZGlydHlcbiAgICAgIH0pO1xuICAgIH0pO1xufVxuIl19

package/esm2022/form/validators/async-function-validator.directive.mjs

@@ -0,0 +1,49 @@
+import { __decorate, __metadata } from "tslib";
+import { Directive, Input, forwardRef } from '@angular/core';
+import { NG_ASYNC_VALIDATORS, Validators, } from '@angular/forms';
+import { ValueHook } from '../../utils';
+import * as i0 from "@angular/core";
+export class AsyncFunctionValidatorDirective {
+    get asyncValidateFn() {
+        return Array.isArray(this.aclAsyncValidateFn)
+            ? Validators.composeAsync(this.aclAsyncValidateFn)
+            : this.aclAsyncValidateFn;
+    }
+    validate(control) {
+        return this.asyncValidateFn?.(control);
+    }
+    registerOnValidatorChange(fn) {
+        this.onValidatorChange = fn;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: AsyncFunctionValidatorDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.1.1", type: AsyncFunctionValidatorDirective, isStandalone: true, selector: "[aclAsyncValidateFn][ngModel],[aclAsyncValidateFn][formControl],[aclAsyncValidateFn][formControlName]", inputs: { aclAsyncValidateFn: "aclAsyncValidateFn" }, providers: [
+            {
+                provide: NG_ASYNC_VALIDATORS,
+                useExisting: forwardRef(() => AsyncFunctionValidatorDirective),
+                multi: true,
+            },
+        ], ngImport: i0 }); }
+}
+__decorate([
+    ValueHook(null, null, function () {
+        this.onValidatorChange?.();
+    }),
+    __metadata("design:type", Object)
+], AsyncFunctionValidatorDirective.prototype, "aclAsyncValidateFn", void 0);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: AsyncFunctionValidatorDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    standalone: true,
+                    selector: '[aclAsyncValidateFn][ngModel],[aclAsyncValidateFn][formControl],[aclAsyncValidateFn][formControlName]',
+                    providers: [
+                        {
+                            provide: NG_ASYNC_VALIDATORS,
+                            useExisting: forwardRef(() => AsyncFunctionValidatorDirective),
+                            multi: true,
+                        },
+                    ],
+                }]
+        }], propDecorators: { aclAsyncValidateFn: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/form/validators/dns1123-subdomain.mjs

@@ -0,0 +1,42 @@
+/**
+ * https://kubernetes.io/zh/docs/concepts/overview/working-with-objects/names/
+  const dns1123LabelFmt string = "[a-z0-9]([-a-z0-9]*[a-z0-9])?"
+  const dns1123SubdomainFmt string = dns1123LabelFmt + "(\\." + dns1123LabelFmt + ")*"
+  const dns1123SubdomainErrorMsg string = "a lowercase RFC 1123 subdomain must consist of lower case alphanumeric characters, '-' or '.', and must start and end with an alphanumeric character"
+
+  // DNS1123SubdomainMaxLength is a subdomain's max length in DNS (RFC 1123)
+  const DNS1123SubdomainMaxLength int = 253
+
+  var dns1123SubdomainRegexp = regexp.MustCompile("^" + dns1123SubdomainFmt + "$")
+
+  // IsDNS1123Subdomain tests for a string that conforms to the definition of a
+  // subdomain in DNS (RFC 1123).
+  func IsDNS1123Subdomain(value string) []string {
+    var errs []string
+    if len(value) > DNS1123SubdomainMaxLength {
+      errs = append(errs, MaxLenError(DNS1123SubdomainMaxLength))
+    }
+    if !dns1123SubdomainRegexp.MatchString(value) {
+      errs = append(errs, RegexError(dns1123SubdomainErrorMsg, dns1123SubdomainFmt, "example.com"))
+    }
+    return errs
+  }
+ */
+export function DNS1123SubdomainValidator(ctrl) {
+    const value = ctrl.value;
+    if (!value) {
+        return null;
+    }
+    if (value.length > 253) {
+        return {
+            domain: true,
+        };
+    }
+    const regex = /^[\da-z]([\da-z-]*[\da-z])?(\.[\da-z]([\da-z-]*[\da-z])?)*$/;
+    return regex.test(value)
+        ? null
+        : {
+            domain: true,
+        };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/form/validators/function-validator.directive.mjs

@@ -0,0 +1,49 @@
+import { __decorate, __metadata } from "tslib";
+import { Directive, Input, forwardRef } from '@angular/core';
+import { NG_VALIDATORS, Validators, } from '@angular/forms';
+import { ValueHook } from '../../utils';
+import * as i0 from "@angular/core";
+export class FunctionValidatorDirective {
+    get validateFn() {
+        return Array.isArray(this.aclValidateFn)
+            ? Validators.compose(this.aclValidateFn)
+            : this.aclValidateFn;
+    }
+    validate(control) {
+        return this.validateFn?.(control);
+    }
+    registerOnValidatorChange(fn) {
+        this.onValidatorChange = fn;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: FunctionValidatorDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.1.1", type: FunctionValidatorDirective, isStandalone: true, selector: "[aclValidateFn][ngModel],[aclValidateFn][formControl],[aclValidateFn][formControlName]", inputs: { aclValidateFn: "aclValidateFn" }, providers: [
+            {
+                provide: NG_VALIDATORS,
+                useExisting: forwardRef(() => FunctionValidatorDirective),
+                multi: true,
+            },
+        ], ngImport: i0 }); }
+}
+__decorate([
+    ValueHook(null, null, function () {
+        this.onValidatorChange?.();
+    }),
+    __metadata("design:type", Object)
+], FunctionValidatorDirective.prototype, "aclValidateFn", void 0);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: FunctionValidatorDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    standalone: true,
+                    selector: '[aclValidateFn][ngModel],[aclValidateFn][formControl],[aclValidateFn][formControlName]',
+                    providers: [
+                        {
+                            provide: NG_VALIDATORS,
+                            useExisting: forwardRef(() => FunctionValidatorDirective),
+                            multi: true,
+                        },
+                    ],
+                }]
+        }], propDecorators: { aclValidateFn: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/form/validators/index.mjs

@@ -0,0 +1,10 @@
+export * from './utils';
+export * from './dns1123-subdomain';
+export * from './resource-limit';
+export * from './strong-password';
+export * from './not-be-validator.directive';
+export * from './one-of-validator.directive';
+export * from './function-validator.directive';
+export * from './async-function-validator.directive';
+export * from './maxlength-minlength-validator.directive';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9saWJzL2R5bmFtaWMtcGx1Z2luLXNoYXJlZC9zcmMvZm9ybS92YWxpZGF0b3JzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsU0FBUyxDQUFDO0FBQ3hCLGNBQWMscUJBQXFCLENBQUM7QUFDcEMsY0FBYyxrQkFBa0IsQ0FBQztBQUNqQyxjQUFjLG1CQUFtQixDQUFDO0FBQ2xDLGNBQWMsOEJBQThCLENBQUM7QUFDN0MsY0FBYyw4QkFBOEIsQ0FBQztBQUM3QyxjQUFjLGdDQUFnQyxDQUFDO0FBQy9DLGNBQWMsc0NBQXNDLENBQUM7QUFDckQsY0FBYywyQ0FBMkMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vdXRpbHMnO1xuZXhwb3J0ICogZnJvbSAnLi9kbnMxMTIzLXN1YmRvbWFpbic7XG5leHBvcnQgKiBmcm9tICcuL3Jlc291cmNlLWxpbWl0JztcbmV4cG9ydCAqIGZyb20gJy4vc3Ryb25nLXBhc3N3b3JkJztcbmV4cG9ydCAqIGZyb20gJy4vbm90LWJlLXZhbGlkYXRvci5kaXJlY3RpdmUnO1xuZXhwb3J0ICogZnJvbSAnLi9vbmUtb2YtdmFsaWRhdG9yLmRpcmVjdGl2ZSc7XG5leHBvcnQgKiBmcm9tICcuL2Z1bmN0aW9uLXZhbGlkYXRvci5kaXJlY3RpdmUnO1xuZXhwb3J0ICogZnJvbSAnLi9hc3luYy1mdW5jdGlvbi12YWxpZGF0b3IuZGlyZWN0aXZlJztcbmV4cG9ydCAqIGZyb20gJy4vbWF4bGVuZ3RoLW1pbmxlbmd0aC12YWxpZGF0b3IuZGlyZWN0aXZlJztcbiJdfQ==

package/esm2022/form/validators/maxlength-minlength-validator.directive.mjs

@@ -0,0 +1,71 @@
+import { Directive, forwardRef, Input } from '@angular/core';
+import { MaxLengthValidator, MinLengthValidator, NG_VALIDATORS, } from '@angular/forms';
+import * as i0 from "@angular/core";
+/**
+ * 功能和 MaxLengthValidator 完全一样，唯一的区别就是不设置 host maxlength attribute
+ * 使用场景：ngModel 的表单希望设置 maxlength validator 但不相限制输入框输入的字符。
+ * 比如产品希望最长 20 个字符，超过 20 个字符红色提醒
+ * https://github.com/angular/angular/blob/main/packages/forms/src/directives/validators.ts#L591
+ */
+export class MaxLengthValidatorDirective extends MaxLengthValidator {
+    constructor() {
+        super(...arguments);
+        this.inputName = 'aclMaxlength';
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: MaxLengthValidatorDirective, deps: null, target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.1.1", type: MaxLengthValidatorDirective, isStandalone: true, selector: "[aclMaxlength][formControlName],[aclMaxlength][formControl],[aclMaxlength][ngModel]", inputs: { aclMaxlength: "aclMaxlength" }, providers: [
+            {
+                provide: NG_VALIDATORS,
+                useExisting: forwardRef(() => MaxLengthValidatorDirective),
+                multi: true,
+            },
+        ], usesInheritance: true, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: MaxLengthValidatorDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    standalone: true,
+                    selector: '[aclMaxlength][formControlName],[aclMaxlength][formControl],[aclMaxlength][ngModel]',
+                    providers: [
+                        {
+                            provide: NG_VALIDATORS,
+                            useExisting: forwardRef(() => MaxLengthValidatorDirective),
+                            multi: true,
+                        },
+                    ],
+                }]
+        }], propDecorators: { aclMaxlength: [{
+                type: Input
+            }] } });
+// 同上
+export class MinLengthValidatorDirective extends MinLengthValidator {
+    constructor() {
+        super(...arguments);
+        this.inputName = 'aclMinlength';
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: MinLengthValidatorDirective, deps: null, target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.1.1", type: MinLengthValidatorDirective, isStandalone: true, selector: "[aclMinlength][formControlName],[aclMinlength][formControl],[aclMinlength][ngModel]", inputs: { aclMinlength: "aclMinlength" }, providers: [
+            {
+                provide: NG_VALIDATORS,
+                useExisting: forwardRef(() => MinLengthValidatorDirective),
+                multi: true,
+            },
+        ], usesInheritance: true, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: MinLengthValidatorDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    standalone: true,
+                    selector: '[aclMinlength][formControlName],[aclMinlength][formControl],[aclMinlength][ngModel]',
+                    providers: [
+                        {
+                            provide: NG_VALIDATORS,
+                            useExisting: forwardRef(() => MinLengthValidatorDirective),
+                            multi: true,
+                        },
+                    ],
+                }]
+        }], propDecorators: { aclMinlength: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/form/validators/not-be-validator.directive.mjs

@@ -0,0 +1,56 @@
+import { __decorate, __metadata } from "tslib";
+import { Directive, Input, forwardRef } from '@angular/core';
+import { NG_VALIDATORS, } from '@angular/forms';
+import { ValueHook } from '../../utils';
+import * as i0 from "@angular/core";
+export class NotBeValidatorDirective {
+    validate(control) {
+        const value = control.value;
+        if (this.notBeValues?.some(notBeValue => typeof notBeValue === 'string'
+            ? notBeValue === value
+            : notBeValue?.test(value))) {
+            return {
+                notBe: control.value,
+            };
+        }
+    }
+    registerOnValidatorChange(fn) {
+        this.onValidatorChange = fn;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: NotBeValidatorDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.1.1", type: NotBeValidatorDirective, isStandalone: true, selector: "[aclNotBe][ngModel],[aclNotBe][formControl],[aclNotBe][formControlName]", inputs: { aclNotBe: "aclNotBe" }, providers: [
+            {
+                provide: NG_VALIDATORS,
+                useExisting: forwardRef(() => NotBeValidatorDirective),
+                multi: true,
+            },
+        ], ngImport: i0 }); }
+}
+__decorate([
+    ValueHook(null, null, function (notBe) {
+        this.notBeValues = notBe
+            ? Array.isArray(notBe)
+                ? notBe
+                : [notBe]
+            : null;
+        this.onValidatorChange?.();
+    }),
+    __metadata("design:type", Object)
+], NotBeValidatorDirective.prototype, "aclNotBe", void 0);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: NotBeValidatorDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    standalone: true,
+                    selector: '[aclNotBe][ngModel],[aclNotBe][formControl],[aclNotBe][formControlName]',
+                    providers: [
+                        {
+                            provide: NG_VALIDATORS,
+                            useExisting: forwardRef(() => NotBeValidatorDirective),
+                            multi: true,
+                        },
+                    ],
+                }]
+        }], propDecorators: { aclNotBe: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibm90LWJlLXZhbGlkYXRvci5kaXJlY3RpdmUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9saWJzL2R5bmFtaWMtcGx1Z2luLXNoYXJlZC9zcmMvZm9ybS92YWxpZGF0b3JzL25vdC1iZS12YWxpZGF0b3IuZGlyZWN0aXZlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFBQSxPQUFPLEVBQUUsU0FBUyxFQUFFLEtBQUssRUFBRSxVQUFVLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDN0QsT0FBTyxFQUVMLGFBQWEsR0FHZCxNQUFNLGdCQUFnQixDQUFDO0FBRXhCLE9BQU8sRUFBRSxTQUFTLEVBQUUsTUFBTSxhQUFhLENBQUM7O0FBZ0J4QyxNQUFNLE9BQU8sdUJBQXVCO0lBb0JsQyxRQUFRLENBQUMsT0FBd0I7UUFDL0IsTUFBTSxLQUFLLEdBQVcsT0FBTyxDQUFDLEtBQUssQ0FBQztRQUNwQyxJQUNFLElBQUksQ0FBQyxXQUFXLEVBQUUsSUFBSSxDQUFDLFVBQVUsQ0FBQyxFQUFFLENBQ2xDLE9BQU8sVUFBVSxLQUFLLFFBQVE7WUFDNUIsQ0FBQyxDQUFDLFVBQVUsS0FBSyxLQUFLO1lBQ3RCLENBQUMsQ0FBQyxVQUFVLEVBQUUsSUFBSSxDQUFDLEtBQUssQ0FBQyxDQUM1QixFQUNELENBQUM7WUFDRCxPQUFPO2dCQUNMLEtBQUssRUFBRSxPQUFPLENBQUMsS0FBSzthQUNyQixDQUFDO1FBQ0osQ0FBQztJQUNILENBQUM7SUFFRCx5QkFBeUIsQ0FBQyxFQUFjO1FBQ3RDLElBQUksQ0FBQyxpQkFBaUIsR0FBRyxFQUFFLENBQUM7SUFDOUIsQ0FBQzs4R0FyQ1UsdUJBQXVCO2tHQUF2Qix1QkFBdUIsd0pBUnZCO1lBQ1Q7Z0JBQ0UsT0FBTyxFQUFFLGFBQWE7Z0JBQ3RCLFdBQVcsRUFBRSxVQUFVLENBQUMsR0FBRyxFQUFFLENBQUMsdUJBQXVCLENBQUM7Z0JBQ3RELEtBQUssRUFBRSxJQUFJO2FBQ1o7U0FDRjs7QUFnQkQ7SUFiQyxTQUFTLENBQ1IsSUFBSSxFQUNKLElBQUksRUFDSixVQUF5QyxLQUFnQztRQUN2RSxJQUFJLENBQUMsV0FBVyxHQUFHLEtBQUs7WUFDdEIsQ0FBQyxDQUFDLEtBQUssQ0FBQyxPQUFPLENBQUMsS0FBSyxDQUFDO2dCQUNwQixDQUFDLENBQUMsS0FBSztnQkFDUCxDQUFDLENBQUMsQ0FBQyxLQUFLLENBQUM7WUFDWCxDQUFDLENBQUMsSUFBSSxDQUFDO1FBQ1QsSUFBSSxDQUFDLGlCQUFpQixFQUFFLEVBQUUsQ0FBQztJQUM3QixDQUFDLENBQ0Y7O3lEQUVtQzsyRkFkekIsdUJBQXVCO2tCQVpuQyxTQUFTO21CQUFDO29CQUNULFVBQVUsRUFBRSxJQUFJO29CQUNoQixRQUFRLEVBQ04seUVBQXlFO29CQUMzRSxTQUFTLEVBQUU7d0JBQ1Q7NEJBQ0UsT0FBTyxFQUFFLGFBQWE7NEJBQ3RCLFdBQVcsRUFBRSxVQUFVLENBQUMsR0FBRyxFQUFFLHdCQUF3QixDQUFDOzRCQUN0RCxLQUFLLEVBQUUsSUFBSTt5QkFDWjtxQkFDRjtpQkFDRjs4QkFlQyxRQUFRO3NCQURQLEtBQUsiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBEaXJlY3RpdmUsIElucHV0LCBmb3J3YXJkUmVmIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQge1xuICBBYnN0cmFjdENvbnRyb2wsXG4gIE5HX1ZBTElEQVRPUlMsXG4gIFZhbGlkYXRpb25FcnJvcnMsXG4gIFZhbGlkYXRvcixcbn0gZnJvbSAnQGFuZ3VsYXIvZm9ybXMnO1xuXG5pbXBvcnQgeyBWYWx1ZUhvb2sgfSBmcm9tICcuLi8uLi91dGlscyc7XG5cbmV4cG9ydCB0eXBlIE5vdEJlVmFsdWUgPSBzdHJpbmcgfCBSZWdFeHA7XG5cbkBEaXJlY3RpdmUoe1xuICBzdGFuZGFsb25lOiB0cnVlLFxuICBzZWxlY3RvcjpcbiAgICAnW2FjbE5vdEJlXVtuZ01vZGVsXSxbYWNsTm90QmVdW2Zvcm1Db250cm9sXSxbYWNsTm90QmVdW2Zvcm1Db250cm9sTmFtZV0nLFxuICBwcm92aWRlcnM6IFtcbiAgICB7XG4gICAgICBwcm92aWRlOiBOR19WQUxJREFUT1JTLFxuICAgICAgdXNlRXhpc3Rpbmc6IGZvcndhcmRSZWYoKCkgPT4gTm90QmVWYWxpZGF0b3JEaXJlY3RpdmUpLFxuICAgICAgbXVsdGk6IHRydWUsXG4gICAgfSxcbiAgXSxcbn0pXG5leHBvcnQgY2xhc3MgTm90QmVWYWxpZGF0b3JEaXJlY3RpdmUgaW1wbGVtZW50cyBWYWxpZGF0b3Ige1xuICBAVmFsdWVIb29rKFxuICAgIG51bGwsXG4gICAgbnVsbCxcbiAgICBmdW5jdGlvbiAodGhpczogTm90QmVWYWxpZGF0b3JEaXJlY3RpdmUsIG5vdEJlOiBOb3RCZVZhbHVlIHwgTm90QmVWYWx1ZVtdKSB7XG4gICAgICB0aGlzLm5vdEJlVmFsdWVzID0gbm90QmVcbiAgICAgICAgPyBBcnJheS5pc0FycmF5KG5vdEJlKVxuICAgICAgICAgID8gbm90QmVcbiAgICAgICAgICA6IFtub3RCZV1cbiAgICAgICAgOiBudWxsO1xuICAgICAgdGhpcy5vblZhbGlkYXRvckNoYW5nZT8uKCk7XG4gICAgfSxcbiAgKVxuICBASW5wdXQoKVxuICBhY2xOb3RCZTogTm90QmVWYWx1ZSB8IE5vdEJlVmFsdWVbXTtcblxuICBub3RCZVZhbHVlczogTm90QmVWYWx1ZVtdO1xuXG4gIG9uVmFsaWRhdG9yQ2hhbmdlOiAoKSA9PiB2b2lkO1xuXG4gIHZhbGlkYXRlKGNvbnRyb2w6IEFic3RyYWN0Q29udHJvbCk6IFZhbGlkYXRpb25FcnJvcnMge1xuICAgIGNvbnN0IHZhbHVlOiBzdHJpbmcgPSBjb250cm9sLnZhbHVlO1xuICAgIGlmIChcbiAgICAgIHRoaXMubm90QmVWYWx1ZXM/LnNvbWUobm90QmVWYWx1ZSA9PlxuICAgICAgICB0eXBlb2Ygbm90QmVWYWx1ZSA9PT0gJ3N0cmluZydcbiAgICAgICAgICA/IG5vdEJlVmFsdWUgPT09IHZhbHVlXG4gICAgICAgICAgOiBub3RCZVZhbHVlPy50ZXN0KHZhbHVlKSxcbiAgICAgIClcbiAgICApIHtcbiAgICAgIHJldHVybiB7XG4gICAgICAgIG5vdEJlOiBjb250cm9sLnZhbHVlLFxuICAgICAgfTtcbiAgICB9XG4gIH1cblxuICByZWdpc3Rlck9uVmFsaWRhdG9yQ2hhbmdlKGZuOiAoKSA9PiB2b2lkKSB7XG4gICAgdGhpcy5vblZhbGlkYXRvckNoYW5nZSA9IGZuO1xuICB9XG59XG4iXX0=

package/esm2022/form/validators/one-of-validator.directive.mjs

@@ -0,0 +1,57 @@
+import { __decorate, __metadata } from "tslib";
+import { Directive, Input, forwardRef } from '@angular/core';
+import { NG_VALIDATORS, } from '@angular/forms';
+import { ValueHook } from '../../utils';
+import * as i0 from "@angular/core";
+export class OneOfValidatorDirective {
+    validate(control) {
+        const value = control.value;
+        if (this.oneOfValues &&
+            !this.oneOfValues?.some(oneOfValue => typeof oneOfValue === 'string'
+                ? oneOfValue === value
+                : oneOfValue?.test(value))) {
+            return {
+                oneOf: control.value,
+            };
+        }
+    }
+    registerOnValidatorChange(fn) {
+        this.onValidatorChange = fn;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: OneOfValidatorDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.1.1", type: OneOfValidatorDirective, isStandalone: true, selector: "[aclOneOf][ngModel],[aclOneOf][formControl],[aclOneOf][formControlName]", inputs: { aclOneOf: "aclOneOf" }, providers: [
+            {
+                provide: NG_VALIDATORS,
+                useExisting: forwardRef(() => OneOfValidatorDirective),
+                multi: true,
+            },
+        ], ngImport: i0 }); }
+}
+__decorate([
+    ValueHook(null, null, function (oneOf) {
+        this.oneOfValues = oneOf
+            ? Array.isArray(oneOf)
+                ? oneOf
+                : [oneOf]
+            : null;
+        this.onValidatorChange?.();
+    }),
+    __metadata("design:type", Object)
+], OneOfValidatorDirective.prototype, "aclOneOf", void 0);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: OneOfValidatorDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    standalone: true,
+                    selector: '[aclOneOf][ngModel],[aclOneOf][formControl],[aclOneOf][formControlName]',
+                    providers: [
+                        {
+                            provide: NG_VALIDATORS,
+                            useExisting: forwardRef(() => OneOfValidatorDirective),
+                            multi: true,
+                        },
+                    ],
+                }]
+        }], propDecorators: { aclOneOf: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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