cmat 0.0.3

package/esm2022/components/password-strength/animations/index.mjs

@@ -0,0 +1,48 @@
+import { animate, animation, keyframes, style } from '@angular/animations';
+export const flipInX = flipIn(1, 1, 0);
+export const flipInY = flipIn(1, 0, 1);
+export const shake = animation(animate('{{ timing }}s {{ delay }}s', keyframes([
+    style({ transform: 'translate3d(0, 0, 0)', offset: 0 }),
+    style({ transform: 'translate3d(-10px, 0, 0)', offset: 0.1 }),
+    style({ transform: 'translate3d(10px, 0, 0)', offset: 0.2 }),
+    style({ transform: 'translate3d(-10px, 0, 0)', offset: 0.3 }),
+    style({ transform: 'translate3d(10px, 0, 0)', offset: 0.4 }),
+    style({ transform: 'translate3d(-10px, 0, 0)', offset: 0.5 }),
+    style({ transform: 'translate3d(10px, 0, 0)', offset: 0.6 }),
+    style({ transform: 'translate3d(-10px, 0, 0)', offset: 0.7 }),
+    style({ transform: 'translate3d(10px, 0, 0)', offset: 0.8 }),
+    style({ transform: 'translate3d(-10px, 0, 0)', offset: 0.9 }),
+    style({ transform: 'translate3d(0, 0, 0)', offset: 1 }),
+])), { params: { timing: 1, delay: 0 } });
+function flipIn(timing, rotateX, rotateY) {
+    const params = { timing: timing, delay: 0, rotateX, rotateY };
+    return animation([
+        // eslint-disable-next-line @typescript-eslint/naming-convention
+        style({ 'backface-visibility': 'visible' }),
+        animate('{{ timing }}s {{ delay }}s ease-in', keyframes([
+            style({
+                opacity: 0,
+                transform: 'perspective(400px) rotate3d({{ rotateX }}, {{ rotateY }}, 0, 90deg)',
+                offset: 0,
+            }),
+            style({
+                opacity: 1,
+                transform: 'perspective(400px) rotate3d({{ rotateX }}, {{ rotateY }}, 0, -20deg)',
+                offset: 0.4,
+            }),
+            style({
+                transform: 'perspective(400px) rotate3d({{ rotateX }}, {{ rotateY }}, 0, 10deg)',
+                offset: 0.6,
+            }),
+            style({
+                transform: 'perspective(400px) rotate3d({{ rotateX }}, {{ rotateY }}, 0, -5deg)',
+                offset: 0.8,
+            }),
+            style({
+                transform: 'perspective(400px) rotate3d(0, 0, 0, 0)',
+                offset: 1,
+            }),
+        ])),
+    ], { params });
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/components/password-strength/cmat-components-password-strength.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './public-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY21hdC1jb21wb25lbnRzLXBhc3N3b3JkLXN0cmVuZ3RoLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvY21hdC9jb21wb25lbnRzL3Bhc3N3b3JkLXN0cmVuZ3RoL2NtYXQtY29tcG9uZW50cy1wYXNzd29yZC1zdHJlbmd0aC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUVILGNBQWMsY0FBYyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBHZW5lcmF0ZWQgYnVuZGxlIGluZGV4LiBEbyBub3QgZWRpdC5cbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL3B1YmxpYy1hcGknO1xuIl19

package/esm2022/components/password-strength/enum.mjs

@@ -0,0 +1,17 @@
+/* eslint-disable @typescript-eslint/naming-convention */
+export var Colors;
+(function (Colors) {
+    Colors["primary"] = "primary";
+    Colors["accent"] = "accent";
+    Colors["warn"] = "warn";
+})(Colors || (Colors = {}));
+export var Criteria;
+(function (Criteria) {
+    Criteria["at_least_eight_chars"] = "minChar";
+    Criteria["at_least_one_lower_case_char"] = "lowerCase";
+    Criteria["at_least_one_upper_case_char"] = "upperCase";
+    Criteria["at_least_one_digit_char"] = "digit";
+    Criteria["at_least_one_special_char"] = " specialChar";
+    Criteria["at_custom_chars"] = "customChars";
+})(Criteria || (Criteria = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZW51bS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2NtYXQvY29tcG9uZW50cy9wYXNzd29yZC1zdHJlbmd0aC9lbnVtLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLHlEQUF5RDtBQUN6RCxNQUFNLENBQU4sSUFBWSxNQUlYO0FBSkQsV0FBWSxNQUFNO0lBQ2QsNkJBQW1CLENBQUE7SUFDbkIsMkJBQWlCLENBQUE7SUFDakIsdUJBQWEsQ0FBQTtBQUNqQixDQUFDLEVBSlcsTUFBTSxLQUFOLE1BQU0sUUFJakI7QUFFRCxNQUFNLENBQU4sSUFBWSxRQU9YO0FBUEQsV0FBWSxRQUFRO0lBQ2hCLDRDQUFnQyxDQUFBO0lBQ2hDLHNEQUEwQyxDQUFBO0lBQzFDLHNEQUEwQyxDQUFBO0lBQzFDLDZDQUFpQyxDQUFBO0lBQ2pDLHNEQUEwQyxDQUFBO0lBQzFDLDJDQUErQixDQUFBO0FBQ25DLENBQUMsRUFQVyxRQUFRLEtBQVIsUUFBUSxRQU9uQiIsInNvdXJjZXNDb250ZW50IjpbIi8qIGVzbGludC1kaXNhYmxlIEB0eXBlc2NyaXB0LWVzbGludC9uYW1pbmctY29udmVudGlvbiAqL1xyXG5leHBvcnQgZW51bSBDb2xvcnMge1xyXG4gICAgcHJpbWFyeSA9ICdwcmltYXJ5JyxcclxuICAgIGFjY2VudCA9ICdhY2NlbnQnLFxyXG4gICAgd2FybiA9ICd3YXJuJ1xyXG59XHJcblxyXG5leHBvcnQgZW51bSBDcml0ZXJpYSB7XHJcbiAgICBhdF9sZWFzdF9laWdodF9jaGFycyA9ICdtaW5DaGFyJyxcclxuICAgIGF0X2xlYXN0X29uZV9sb3dlcl9jYXNlX2NoYXIgPSAnbG93ZXJDYXNlJyxcclxuICAgIGF0X2xlYXN0X29uZV91cHBlcl9jYXNlX2NoYXIgPSAndXBwZXJDYXNlJyxcclxuICAgIGF0X2xlYXN0X29uZV9kaWdpdF9jaGFyID0gJ2RpZ2l0JyxcclxuICAgIGF0X2xlYXN0X29uZV9zcGVjaWFsX2NoYXIgPSAnIHNwZWNpYWxDaGFyJyxcclxuICAgIGF0X2N1c3RvbV9jaGFycyA9ICdjdXN0b21DaGFycydcclxufVxyXG4iXX0=

package/esm2022/components/password-strength/mat-pass-toggle-visibility/mat-pass-toggle-visibility.component.mjs

@@ -0,0 +1,27 @@
+import { ChangeDetectionStrategy, Component, Input, ViewEncapsulation } from '@angular/core';
+import { MatIconModule } from '@angular/material/icon';
+import { MatRippleModule } from '@angular/material/core';
+import { MatButtonModule } from '@angular/material/button';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/material/button";
+import * as i2 from "@angular/material/core";
+import * as i3 from "@angular/material/icon";
+export class CmatPassToggleVisibilityComponent {
+    constructor() {
+        this._type = 'text';
+    }
+    get type() {
+        return this.isVisible ? 'text' : 'password';
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.0", ngImport: i0, type: CmatPassToggleVisibilityComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.1.0", type: CmatPassToggleVisibilityComponent, isStandalone: true, selector: "cmat-pass-toggle-visibility", inputs: { isVisible: "isVisible", tabindex: "tabindex" }, exportAs: ["cmatPassToggleVisibility"], ngImport: i0, template: "<button (click)=\"isVisible = !isVisible\" type=\"button\" class=\"mat-icon-button cdk-focused cdk-mouse-focused\"\n    mat-icon-button [matRippleCentered]=\"true\" matRipple [attr.tabindex]=\"tabindex ? tabindex : null\">\n    <mat-icon svgIcon=\"{{isVisible ? 'mat_outline:visibility' : 'mat_outline:visibility_off' }}\"></mat-icon>\n</button>", dependencies: [{ kind: "ngmodule", type: MatButtonModule }, { kind: "component", type: i1.MatIconButton, selector: "button[mat-icon-button]", exportAs: ["matButton"] }, { kind: "ngmodule", type: MatRippleModule }, { kind: "directive", type: i2.MatRipple, selector: "[mat-ripple], [matRipple]", inputs: ["matRippleColor", "matRippleUnbounded", "matRippleCentered", "matRippleRadius", "matRippleAnimation", "matRippleDisabled", "matRippleTrigger"], exportAs: ["matRipple"] }, { kind: "ngmodule", type: MatIconModule }, { kind: "component", type: i3.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.0", ngImport: i0, type: CmatPassToggleVisibilityComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'cmat-pass-toggle-visibility', encapsulation: ViewEncapsulation.None, changeDetection: ChangeDetectionStrategy.OnPush, exportAs: 'cmatPassToggleVisibility', standalone: true, imports: [MatButtonModule, MatRippleModule, MatIconModule], template: "<button (click)=\"isVisible = !isVisible\" type=\"button\" class=\"mat-icon-button cdk-focused cdk-mouse-focused\"\n    mat-icon-button [matRippleCentered]=\"true\" matRipple [attr.tabindex]=\"tabindex ? tabindex : null\">\n    <mat-icon svgIcon=\"{{isVisible ? 'mat_outline:visibility' : 'mat_outline:visibility_off' }}\"></mat-icon>\n</button>" }]
+        }], propDecorators: { isVisible: [{
+                type: Input
+            }], tabindex: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWF0LXBhc3MtdG9nZ2xlLXZpc2liaWxpdHkuY29tcG9uZW50LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvY21hdC9jb21wb25lbnRzL3Bhc3N3b3JkLXN0cmVuZ3RoL21hdC1wYXNzLXRvZ2dsZS12aXNpYmlsaXR5L21hdC1wYXNzLXRvZ2dsZS12aXNpYmlsaXR5LmNvbXBvbmVudC50cyIsIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2NtYXQvY29tcG9uZW50cy9wYXNzd29yZC1zdHJlbmd0aC9tYXQtcGFzcy10b2dnbGUtdmlzaWJpbGl0eS9tYXQtcGFzcy10b2dnbGUtdmlzaWJpbGl0eS5jb21wb25lbnQuaHRtbCJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsdUJBQXVCLEVBQUUsU0FBUyxFQUFFLEtBQUssRUFBRSxpQkFBaUIsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUM3RixPQUFPLEVBQUUsYUFBYSxFQUFFLE1BQU0sd0JBQXdCLENBQUM7QUFDdkQsT0FBTyxFQUFFLGVBQWUsRUFBRSxNQUFNLHdCQUF3QixDQUFDO0FBQ3pELE9BQU8sRUFBRSxlQUFlLEVBQUUsTUFBTSwwQkFBMEIsQ0FBQzs7Ozs7QUFhM0QsTUFBTSxPQUFPLGlDQUFpQztJQVQ5QztRQWVJLFVBQUssR0FBUyxNQUFNLENBQUM7S0FNeEI7SUFKRyxJQUFJLElBQUk7UUFDSixPQUFPLElBQUksQ0FBQyxTQUFTLENBQUMsQ0FBQyxDQUFDLE1BQU0sQ0FBQyxDQUFDLENBQUMsVUFBVSxDQUFDO0lBQ2hELENBQUM7OEdBVlEsaUNBQWlDO2tHQUFqQyxpQ0FBaUMseUxDaEI5QywyVkFHUywyQ0RXSyxlQUFlLDJJQUFFLGVBQWUsa1NBQUUsYUFBYTs7MkZBRWhELGlDQUFpQztrQkFUN0MsU0FBUzsrQkFDSSw2QkFBNkIsaUJBRXhCLGlCQUFpQixDQUFDLElBQUksbUJBQ3BCLHVCQUF1QixDQUFDLE1BQU0sWUFDckMsMEJBQTBCLGNBQ3hCLElBQUksV0FDUCxDQUFDLGVBQWUsRUFBRSxlQUFlLEVBQUUsYUFBYSxDQUFDOzhCQUkxRCxTQUFTO3NCQURSLEtBQUs7Z0JBR04sUUFBUTtzQkFEUCxLQUFLIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQ2hhbmdlRGV0ZWN0aW9uU3RyYXRlZ3ksIENvbXBvbmVudCwgSW5wdXQsIFZpZXdFbmNhcHN1bGF0aW9uIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBNYXRJY29uTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvbWF0ZXJpYWwvaWNvbic7XG5pbXBvcnQgeyBNYXRSaXBwbGVNb2R1bGUgfSBmcm9tICdAYW5ndWxhci9tYXRlcmlhbC9jb3JlJztcbmltcG9ydCB7IE1hdEJ1dHRvbk1vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL21hdGVyaWFsL2J1dHRvbic7XG5cbnR5cGUgVHlwZSA9ICd0ZXh0JyB8ICdwYXNzd29yZCc7XG5cbkBDb21wb25lbnQoe1xuICAgIHNlbGVjdG9yOiAnY21hdC1wYXNzLXRvZ2dsZS12aXNpYmlsaXR5JyxcbiAgICB0ZW1wbGF0ZVVybDogJy4vbWF0LXBhc3MtdG9nZ2xlLXZpc2liaWxpdHkuY29tcG9uZW50Lmh0bWwnLFxuICAgIGVuY2Fwc3VsYXRpb246IFZpZXdFbmNhcHN1bGF0aW9uLk5vbmUsXG4gICAgY2hhbmdlRGV0ZWN0aW9uOiBDaGFuZ2VEZXRlY3Rpb25TdHJhdGVneS5PblB1c2gsXG4gICAgZXhwb3J0QXM6ICdjbWF0UGFzc1RvZ2dsZVZpc2liaWxpdHknLFxuICAgIHN0YW5kYWxvbmU6IHRydWUsXG4gICAgaW1wb3J0czogW01hdEJ1dHRvbk1vZHVsZSwgTWF0UmlwcGxlTW9kdWxlLCBNYXRJY29uTW9kdWxlXVxufSlcbmV4cG9ydCBjbGFzcyBDbWF0UGFzc1RvZ2dsZVZpc2liaWxpdHlDb21wb25lbnQge1xuICAgIEBJbnB1dCgpXG4gICAgaXNWaXNpYmxlOiBib29sZWFuO1xuICAgIEBJbnB1dCgpXG4gICAgdGFiaW5kZXg/OiBzdHJpbmc7XG5cbiAgICBfdHlwZTogVHlwZSA9ICd0ZXh0JztcblxuICAgIGdldCB0eXBlKCk6IHN0cmluZyB7XG4gICAgICAgIHJldHVybiB0aGlzLmlzVmlzaWJsZSA/ICd0ZXh0JyA6ICdwYXNzd29yZCc7XG4gICAgfVxuXG59XG4iLCI8YnV0dG9uIChjbGljayk9XCJpc1Zpc2libGUgPSAhaXNWaXNpYmxlXCIgdHlwZT1cImJ1dHRvblwiIGNsYXNzPVwibWF0LWljb24tYnV0dG9uIGNkay1mb2N1c2VkIGNkay1tb3VzZS1mb2N1c2VkXCJcbiAgICBtYXQtaWNvbi1idXR0b24gW21hdFJpcHBsZUNlbnRlcmVkXT1cInRydWVcIiBtYXRSaXBwbGUgW2F0dHIudGFiaW5kZXhdPVwidGFiaW5kZXggPyB0YWJpbmRleCA6IG51bGxcIj5cbiAgICA8bWF0LWljb24gc3ZnSWNvbj1cInt7aXNWaXNpYmxlID8gJ21hdF9vdXRsaW5lOnZpc2liaWxpdHknIDogJ21hdF9vdXRsaW5lOnZpc2liaWxpdHlfb2ZmJyB9fVwiPjwvbWF0LWljb24+XG48L2J1dHRvbj4iXX0=

package/esm2022/components/password-strength/mat-password-strength/mat-password-strength.component.mjs

@@ -0,0 +1,206 @@
+import { ChangeDetectionStrategy, Component, EventEmitter, Input, Output, ViewEncapsulation } from '@angular/core';
+import { FormControl, Validators } from '@angular/forms';
+import { Colors, Criteria } from '../enum';
+import { CmatPasswordStrengthValidator } from '../mat-password-strength-validator';
+import { RegExpValidator } from '../regexp.class';
+import { MatProgressBarModule } from '@angular/material/progress-bar';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/material/progress-bar";
+export class CmatPasswordStrengthComponent {
+    constructor() {
+        this.enableLengthRule = true;
+        this.enableLowerCaseLetterRule = true;
+        this.enableUpperCaseLetterRule = true;
+        this.enableDigitRule = true;
+        this.enableSpecialCharRule = true;
+        this.min = 8;
+        this.max = 30;
+        this.warnThreshold = 21;
+        this.accentThreshold = 81;
+        this.strengthChanged = new EventEmitter();
+        this.criteriaMap = new Map();
+        // TO ACCESS VIA CONTENT CHILD
+        this.passwordFormControl = new FormControl();
+        this.passwordConfirmationFormControl = new FormControl();
+        this.validatorsArray = [];
+        this.cmatPasswordStrengthValidator = new CmatPasswordStrengthValidator();
+        this._strength = 0;
+        this._color = 'warn';
+    }
+    get strength() {
+        return this._strength ? this._strength : 0;
+    }
+    get color() {
+        return this._color;
+    }
+    ngOnInit() {
+        this.setRulesAndValidators();
+        if (this.password) {
+            this.calculatePasswordStrength();
+        }
+    }
+    ngOnChanges(changes) {
+        if ((changes['externalError'] && changes['externalError'].firstChange) || changes['password'].isFirstChange()) {
+            return;
+        }
+        else if (changes['externalError'] && changes['externalError'].currentValue) {
+            this._color = Colors.warn;
+            return;
+        }
+        else if (changes['password'].previousValue === changes['password'].currentValue && !changes['password'].firstChange) {
+            this._checkPassword();
+        }
+        else if (this.password && this.password.length > 0) {
+            this._checkPassword();
+        }
+        else {
+            this.reset();
+        }
+    }
+    parseCustomValidatorsRegex() {
+        if (this.customValidator instanceof RegExp) {
+            return this.customValidator;
+        }
+        else {
+            return RegExp(this.customValidator);
+        }
+    }
+    setRulesAndValidators() {
+        this.validatorsArray = [];
+        this.criteriaMap = new Map();
+        this.passwordConfirmationFormControl
+            .setValidators(Validators.compose([
+            Validators.required, this.cmatPasswordStrengthValidator.confirm(this.password)
+        ]));
+        this.validatorsArray.push(Validators.required);
+        if (this.enableLengthRule) {
+            this.criteriaMap.set(Criteria.at_least_eight_chars, RegExp(`^.{${this.min},${this.max}}$`));
+            this.validatorsArray.push(Validators.minLength(this.min));
+            this.validatorsArray.push(Validators.maxLength(this.max));
+        }
+        if (this.enableLowerCaseLetterRule) {
+            this.criteriaMap.set(Criteria.at_least_one_lower_case_char, RegExpValidator.lowerCase);
+            this.validatorsArray.push(Validators.pattern(RegExpValidator.lowerCase));
+        }
+        if (this.enableUpperCaseLetterRule) {
+            this.criteriaMap.set(Criteria.at_least_one_upper_case_char, RegExpValidator.upperCase);
+            this.validatorsArray.push(Validators.pattern(RegExpValidator.upperCase));
+        }
+        if (this.enableDigitRule) {
+            this.criteriaMap.set(Criteria.at_least_one_digit_char, RegExpValidator.digit);
+            this.validatorsArray.push(Validators.pattern(RegExpValidator.digit));
+        }
+        if (this.enableSpecialCharRule) {
+            this.criteriaMap.set(Criteria.at_least_one_special_char, RegExpValidator.specialChar);
+            this.validatorsArray.push(Validators.pattern(RegExpValidator.specialChar));
+        }
+        if (this.customValidator) {
+            this.criteriaMap.set(Criteria.at_custom_chars, this.parseCustomValidatorsRegex());
+            this.validatorsArray.push(Validators.pattern(this.parseCustomValidatorsRegex()));
+        }
+        this.criteriaMap.forEach((value, key) => {
+            this.validatorsArray.push(this.cmatPasswordStrengthValidator.validate(key, value));
+        });
+        this.passwordFormControl.setValidators(Validators.compose([...this.validatorsArray]));
+        this.validators = Validators.compose([...this.validatorsArray]);
+    }
+    calculatePasswordStrength() {
+        const requirements = [];
+        const unit = 100 / this.criteriaMap.size;
+        requirements.push(this.enableLengthRule ? this._containAtLeastMinChars() : false, this.enableLowerCaseLetterRule ? this._containAtLeastOneLowerCaseLetter() : false, this.enableUpperCaseLetterRule ? this._containAtLeastOneUpperCaseLetter() : false, this.enableDigitRule ? this._containAtLeastOneDigit() : false, this.enableSpecialCharRule ? this._containAtLeastOneSpecialChar() : false, this.customValidator ? this._containCustomChars() : false);
+        this._strength = requirements.filter(v => v).length * unit;
+        this.strengthChanged.emit(this.strength);
+        this.setRulesAndValidators();
+        if (this._strength < this.warnThreshold) {
+            this._color = Colors.warn;
+        }
+        else if (this._strength < this.accentThreshold) {
+            this._color = Colors.accent;
+        }
+        else {
+            this._color = Colors.primary;
+        }
+    }
+    reset() {
+        this._strength = 0;
+        this.containAtLeastMinChars =
+            this.containAtLeastOneLowerCaseLetter =
+                this.containAtLeastOneUpperCaseLetter =
+                    this.containAtLeastOneDigit =
+                        this.containAtCustomChars =
+                            this.containAtLeastOneSpecialChar = false;
+        this._color = Colors.warn;
+        this.strengthChanged.emit(this.strength);
+    }
+    _containAtLeastMinChars() {
+        this.containAtLeastMinChars = this.password.length >= this.min;
+        return this.containAtLeastMinChars;
+    }
+    _containAtLeastOneLowerCaseLetter() {
+        this.containAtLeastOneLowerCaseLetter =
+            this.criteriaMap
+                .get(Criteria.at_least_one_lower_case_char)?.test(this.password);
+        return this.containAtLeastOneLowerCaseLetter || false;
+    }
+    _containAtLeastOneUpperCaseLetter() {
+        this.containAtLeastOneUpperCaseLetter =
+            this.criteriaMap
+                .get(Criteria.at_least_one_upper_case_char)?.test(this.password);
+        return this.containAtLeastOneUpperCaseLetter || false;
+    }
+    _containAtLeastOneDigit() {
+        this.containAtLeastOneDigit =
+            this.criteriaMap
+                .get(Criteria.at_least_one_digit_char)?.test(this.password);
+        return this.containAtLeastOneDigit || false;
+    }
+    _containAtLeastOneSpecialChar() {
+        this.containAtLeastOneSpecialChar =
+            this.criteriaMap
+                .get(Criteria.at_least_one_special_char)?.test(this.password);
+        return this.containAtLeastOneSpecialChar || false;
+    }
+    _containCustomChars() {
+        this.containAtCustomChars =
+            this.criteriaMap
+                .get(Criteria.at_custom_chars)?.test(this.password);
+        return this.containAtCustomChars || false;
+    }
+    _checkPassword() {
+        this.calculatePasswordStrength();
+        this.passwordConfirmationFormControl.updateValueAndValidity();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.0", ngImport: i0, type: CmatPasswordStrengthComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.1.0", type: CmatPasswordStrengthComponent, isStandalone: true, selector: "cmat-password-strength", inputs: { password: "password", externalError: "externalError", enableLengthRule: "enableLengthRule", enableLowerCaseLetterRule: "enableLowerCaseLetterRule", enableUpperCaseLetterRule: "enableUpperCaseLetterRule", enableDigitRule: "enableDigitRule", enableSpecialCharRule: "enableSpecialCharRule", min: "min", max: "max", customValidator: "customValidator", warnThreshold: "warnThreshold", accentThreshold: "accentThreshold" }, outputs: { strengthChanged: "strengthChanged" }, exportAs: ["cmatPasswordStrength"], usesOnChanges: true, ngImport: i0, template: "<mat-progress-bar mode=\"determinate\" [color]=\"color\" [value]=\"strength\"></mat-progress-bar>", dependencies: [{ kind: "ngmodule", type: MatProgressBarModule }, { kind: "component", type: i1.MatProgressBar, selector: "mat-progress-bar", inputs: ["color", "value", "bufferValue", "mode"], outputs: ["animationEnd"], exportAs: ["matProgressBar"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.0", ngImport: i0, type: CmatPasswordStrengthComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'cmat-password-strength', exportAs: 'cmatPasswordStrength', encapsulation: ViewEncapsulation.None, changeDetection: ChangeDetectionStrategy.OnPush, standalone: true, imports: [MatProgressBarModule], template: "<mat-progress-bar mode=\"determinate\" [color]=\"color\" [value]=\"strength\"></mat-progress-bar>" }]
+        }], propDecorators: { password: [{
+                type: Input
+            }], externalError: [{
+                type: Input
+            }], enableLengthRule: [{
+                type: Input
+            }], enableLowerCaseLetterRule: [{
+                type: Input
+            }], enableUpperCaseLetterRule: [{
+                type: Input
+            }], enableDigitRule: [{
+                type: Input
+            }], enableSpecialCharRule: [{
+                type: Input
+            }], min: [{
+                type: Input
+            }], max: [{
+                type: Input
+            }], customValidator: [{
+                type: Input
+            }], warnThreshold: [{
+                type: Input
+            }], accentThreshold: [{
+                type: Input
+            }], strengthChanged: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"mat-password-strength.component.js","sourceRoot":"","sources":["../../../../../../projects/cmat/components/password-strength/mat-password-strength/mat-password-strength.component.ts","../../../../../../projects/cmat/components/password-strength/mat-password-strength/mat-password-strength.component.html"],"names":[],"mappings":"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","sourcesContent":["import { ChangeDetectionStrategy, Component, EventEmitter, Input, OnChanges, OnInit, Output, SimpleChanges, ViewEncapsulation } from '@angular/core';\r\nimport { FormControl, ValidatorFn, Validators } from '@angular/forms';\r\nimport { ThemePalette } from '@angular/material/core';\r\nimport { Colors, Criteria } from '../enum';\r\nimport { CmatPasswordStrengthValidator } from '../mat-password-strength-validator';\r\nimport { RegExpValidator } from '../regexp.class';\r\nimport { MatProgressBarModule } from '@angular/material/progress-bar';\r\n\r\n@Component({\r\n    selector: 'cmat-password-strength',\r\n    exportAs: 'cmatPasswordStrength',\r\n    templateUrl: './mat-password-strength.component.html',\r\n    encapsulation: ViewEncapsulation.None,\r\n    changeDetection: ChangeDetectionStrategy.OnPush,\r\n    standalone: true,\r\n    imports: [MatProgressBarModule]\r\n})\r\nexport class CmatPasswordStrengthComponent implements OnInit, OnChanges {\r\n    @Input() password: string;\r\n    @Input() externalError: boolean;\r\n\r\n    @Input() enableLengthRule = true;\r\n    @Input() enableLowerCaseLetterRule = true;\r\n    @Input() enableUpperCaseLetterRule = true;\r\n    @Input() enableDigitRule = true;\r\n    @Input() enableSpecialCharRule = true;\r\n\r\n    @Input() min = 8;\r\n    @Input() max = 30;\r\n    @Input() customValidator: RegExp;\r\n\r\n    @Input() warnThreshold = 21;\r\n    @Input() accentThreshold = 81;\r\n\r\n    @Output()\r\n    strengthChanged: EventEmitter<number> = new EventEmitter();\r\n\r\n    criteriaMap = new Map<Criteria, RegExp>();\r\n\r\n    containAtLeastMinChars: boolean | void;\r\n    containAtLeastOneLowerCaseLetter: boolean | void;\r\n    containAtLeastOneUpperCaseLetter: boolean | void;\r\n    containAtLeastOneDigit: boolean | void;\r\n    containAtLeastOneSpecialChar: boolean | void;\r\n    containAtCustomChars: boolean | void;\r\n\r\n    // TO ACCESS VIA CONTENT CHILD\r\n    passwordFormControl: FormControl = new FormControl();\r\n    passwordConfirmationFormControl: FormControl = new FormControl();\r\n\r\n    validatorsArray: ValidatorFn[] = [];\r\n    validators: ValidatorFn | null;\r\n    cmatPasswordStrengthValidator = new CmatPasswordStrengthValidator();\r\n\r\n    private _strength = 0;\r\n    private _color: ThemePalette = 'warn';\r\n\r\n    get strength(): number {\r\n        return this._strength ? this._strength : 0;\r\n    }\r\n    get color(): ThemePalette {\r\n        return this._color;\r\n    }\r\n\r\n    ngOnInit(): void {\r\n        this.setRulesAndValidators();\r\n\r\n        if (this.password) {\r\n            this.calculatePasswordStrength();\r\n        }\r\n    }\r\n\r\n    ngOnChanges(changes: SimpleChanges): void {\r\n        if ((changes['externalError'] && changes['externalError'].firstChange) || changes['password'].isFirstChange()) {\r\n            return;\r\n        } else if (changes['externalError'] && changes['externalError'].currentValue) {\r\n            this._color = Colors.warn;\r\n            return;\r\n        } else if (changes['password'].previousValue === changes['password'].currentValue && !changes['password'].firstChange) {\r\n            this._checkPassword();\r\n        } else if (this.password && this.password.length > 0) {\r\n            this._checkPassword();\r\n        } else {\r\n            this.reset();\r\n        }\r\n    }\r\n\r\n    parseCustomValidatorsRegex(): RegExp {\r\n        if (this.customValidator instanceof RegExp) {\r\n            return this.customValidator;\r\n        } else {\r\n            return RegExp(this.customValidator);\r\n        }\r\n    }\r\n\r\n    setRulesAndValidators(): void {\r\n        this.validatorsArray = [];\r\n        this.criteriaMap = new Map<Criteria, RegExp>();\r\n        this.passwordConfirmationFormControl\r\n            .setValidators(Validators.compose([\r\n                Validators.required, this.cmatPasswordStrengthValidator.confirm(this.password)\r\n            ]));\r\n        this.validatorsArray.push(Validators.required);\r\n        if (this.enableLengthRule) {\r\n            this.criteriaMap.set(Criteria.at_least_eight_chars, RegExp(`^.{${this.min},${this.max}}$`));\r\n            this.validatorsArray.push(Validators.minLength(this.min));\r\n            this.validatorsArray.push(Validators.maxLength(this.max));\r\n        }\r\n        if (this.enableLowerCaseLetterRule) {\r\n            this.criteriaMap.set(Criteria.at_least_one_lower_case_char, RegExpValidator.lowerCase);\r\n            this.validatorsArray.push(Validators.pattern(RegExpValidator.lowerCase));\r\n        }\r\n        if (this.enableUpperCaseLetterRule) {\r\n            this.criteriaMap.set(Criteria.at_least_one_upper_case_char, RegExpValidator.upperCase);\r\n            this.validatorsArray.push(Validators.pattern(RegExpValidator.upperCase));\r\n        }\r\n        if (this.enableDigitRule) {\r\n            this.criteriaMap.set(Criteria.at_least_one_digit_char, RegExpValidator.digit);\r\n            this.validatorsArray.push(Validators.pattern(RegExpValidator.digit));\r\n        }\r\n        if (this.enableSpecialCharRule) {\r\n            this.criteriaMap.set(Criteria.at_least_one_special_char, RegExpValidator.specialChar);\r\n            this.validatorsArray.push(Validators.pattern(RegExpValidator.specialChar));\r\n        }\r\n        if (this.customValidator) {\r\n            this.criteriaMap.set(Criteria.at_custom_chars, this.parseCustomValidatorsRegex());\r\n            this.validatorsArray.push(Validators.pattern(this.parseCustomValidatorsRegex()));\r\n        }\r\n\r\n        this.criteriaMap.forEach((value: any, key: string) => {\r\n            this.validatorsArray.push(this.cmatPasswordStrengthValidator.validate(key, value));\r\n        });\r\n\r\n        this.passwordFormControl.setValidators(Validators.compose([...this.validatorsArray]));\r\n        this.validators = Validators.compose([...this.validatorsArray]);\r\n\r\n    }\r\n\r\n    calculatePasswordStrength(): void {\r\n        const requirements: Array<boolean> = [];\r\n        const unit = 100 / this.criteriaMap.size;\r\n\r\n        requirements.push(\r\n            this.enableLengthRule ? this._containAtLeastMinChars() : false,\r\n            this.enableLowerCaseLetterRule ? this._containAtLeastOneLowerCaseLetter() : false,\r\n            this.enableUpperCaseLetterRule ? this._containAtLeastOneUpperCaseLetter() : false,\r\n            this.enableDigitRule ? this._containAtLeastOneDigit() : false,\r\n            this.enableSpecialCharRule ? this._containAtLeastOneSpecialChar() : false,\r\n            this.customValidator ? this._containCustomChars() : false\r\n        );\r\n\r\n        this._strength = requirements.filter(v => v).length * unit;\r\n        this.strengthChanged.emit(this.strength);\r\n        this.setRulesAndValidators();\r\n\r\n        if (this._strength < this.warnThreshold) {\r\n            this._color = Colors.warn;\r\n        } else if (this._strength < this.accentThreshold) {\r\n            this._color = Colors.accent;\r\n        } else {\r\n            this._color = Colors.primary;\r\n        }\r\n    }\r\n\r\n    reset(): void {\r\n        this._strength = 0;\r\n        this.containAtLeastMinChars =\r\n            this.containAtLeastOneLowerCaseLetter =\r\n            this.containAtLeastOneUpperCaseLetter =\r\n            this.containAtLeastOneDigit =\r\n            this.containAtCustomChars =\r\n            this.containAtLeastOneSpecialChar = false;\r\n\r\n        this._color = Colors.warn;\r\n        this.strengthChanged.emit(this.strength);\r\n    }\r\n\r\n    private _containAtLeastMinChars(): boolean {\r\n        this.containAtLeastMinChars = this.password.length >= this.min;\r\n        return this.containAtLeastMinChars;\r\n    }\r\n\r\n    private _containAtLeastOneLowerCaseLetter(): boolean {\r\n        this.containAtLeastOneLowerCaseLetter =\r\n            this.criteriaMap\r\n                .get(Criteria.at_least_one_lower_case_char)?.test(this.password);\r\n        return this.containAtLeastOneLowerCaseLetter || false;\r\n    }\r\n\r\n    private _containAtLeastOneUpperCaseLetter(): boolean {\r\n        this.containAtLeastOneUpperCaseLetter =\r\n            this.criteriaMap\r\n                .get(Criteria.at_least_one_upper_case_char)?.test(this.password);\r\n        return this.containAtLeastOneUpperCaseLetter || false;\r\n    }\r\n\r\n    private _containAtLeastOneDigit(): boolean {\r\n        this.containAtLeastOneDigit =\r\n            this.criteriaMap\r\n                .get(Criteria.at_least_one_digit_char)?.test(this.password);\r\n        return this.containAtLeastOneDigit || false;\r\n    }\r\n\r\n    private _containAtLeastOneSpecialChar(): boolean {\r\n        this.containAtLeastOneSpecialChar =\r\n            this.criteriaMap\r\n                .get(Criteria.at_least_one_special_char)?.test(this.password);\r\n        return this.containAtLeastOneSpecialChar || false;\r\n    }\r\n\r\n    private _containCustomChars(): boolean {\r\n        this.containAtCustomChars =\r\n            this.criteriaMap\r\n                .get(Criteria.at_custom_chars)?.test(this.password);\r\n        return this.containAtCustomChars || false;\r\n    }\r\n\r\n    private _checkPassword(): void {\r\n        this.calculatePasswordStrength();\r\n        this.passwordConfirmationFormControl.updateValueAndValidity();\r\n    }\r\n}\r\n","<mat-progress-bar mode=\"determinate\" [color]=\"color\" [value]=\"strength\"></mat-progress-bar>"]}

package/esm2022/components/password-strength/mat-password-strength-info/mat-password-strength-info.component.mjs

@@ -0,0 +1,151 @@
+import { ChangeDetectionStrategy, Component, Input, ViewEncapsulation } from '@angular/core';
+import { animate, animateChild, keyframes, query, stagger, style, transition, trigger, useAnimation } from '@angular/animations';
+import { MatIconModule } from '@angular/material/icon';
+import { NgIf } from '@angular/common';
+import { MatCardModule } from '@angular/material/card';
+import { shake } from '../animations';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/material/card";
+import * as i2 from "@angular/material/icon";
+export class CmatPasswordStrengthInfoComponent {
+    constructor() {
+        this.enableScoreInfo = false;
+        this.lowerCaseCriteriaMsg = '包含至少一个小写字母';
+        this.upperCaseCriteriaMsg = '包含至少一个大写字母';
+        this.digitsCriteriaMsg = '包含至少一个数字';
+        this.specialCharsCriteriaMsg = '包含至少一个特殊字符';
+        this.customCharsCriteriaMsg = '包含至少一个传统字符';
+    }
+    ngOnInit() {
+        if (!this.minCharsCriteriaMsg) {
+            this.minCharsCriteriaMsg = `包含至少 ${this.passwordComponent.min} 个字符`;
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.0", ngImport: i0, type: CmatPasswordStrengthInfoComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.1.0", type: CmatPasswordStrengthInfoComponent, isStandalone: true, selector: "cmat-password-strength-info", inputs: { passwordComponent: "passwordComponent", enableScoreInfo: "enableScoreInfo", lowerCaseCriteriaMsg: "lowerCaseCriteriaMsg", upperCaseCriteriaMsg: "upperCaseCriteriaMsg", digitsCriteriaMsg: "digitsCriteriaMsg", specialCharsCriteriaMsg: "specialCharsCriteriaMsg", customCharsCriteriaMsg: "customCharsCriteriaMsg", minCharsCriteriaMsg: "minCharsCriteriaMsg" }, exportAs: ["cmatPasswordStrengthInfo"], ngImport: i0, template: "<mat-card @list class=\"info-card\">\n    <mat-card-content>\n        <div class=\"info-row\" @items *ngIf=\"passwordComponent.enableLowerCaseLetterRule\">\n            <div *ngIf=\"passwordComponent.containAtLeastOneLowerCaseLetter; then done else error\" @flipY>\n            </div>\n            <ng-template #done>\n                <mat-icon @positiveState color=\"primary\" svgIcon=\"mat_outline:done\"></mat-icon>\n            </ng-template>\n            <ng-template #error>\n                <mat-icon @negativeState color=\"warn\" svgIcon=\"mat_outline:error\"></mat-icon>\n            </ng-template>\n            <span>{{lowerCaseCriteriaMsg}}</span>\n        </div>\n\n        <div class=\"info-row\" @items *ngIf=\"passwordComponent.enableUpperCaseLetterRule\">\n            <div *ngIf=\"passwordComponent.containAtLeastOneUpperCaseLetter; then done else error\">\n            </div>\n            <ng-template #done>\n                <mat-icon @positiveState color=\"primary\" svgIcon=\"mat_outline:done\"></mat-icon>\n            </ng-template>\n            <ng-template #error>\n                <mat-icon @negativeState color=\"warn\" svgIcon=\"mat_outline:error\"></mat-icon>\n            </ng-template>\n            <span>{{upperCaseCriteriaMsg}}</span>\n        </div>\n\n        <div class=\"info-row\" @items *ngIf=\"passwordComponent.enableDigitRule\">\n            <div *ngIf=\"passwordComponent.containAtLeastOneDigit; then done else error\">\n            </div>\n            <ng-template #done>\n                <mat-icon @positiveState color=\"primary\" svgIcon=\"mat_outline:done\"></mat-icon>\n            </ng-template>\n            <ng-template #error>\n                <mat-icon @negativeState color=\"warn\" svgIcon=\"mat_outline:error\"></mat-icon>\n            </ng-template>\n            <span>{{digitsCriteriaMsg}}</span>\n        </div>\n\n        <div class=\"info-row\" @items *ngIf=\"passwordComponent.enableSpecialCharRule\">\n            <div *ngIf=\"passwordComponent.containAtLeastOneSpecialChar; then done else error\">\n            </div>\n            <ng-template #done>\n                <mat-icon @positiveState color=\"primary\" svgIcon=\"mat_outline:done\"></mat-icon>\n            </ng-template>\n            <ng-template #error>\n                <mat-icon @negativeState color=\"warn\" svgIcon=\"mat_outline:error\"></mat-icon>\n            </ng-template>\n            <span>{{specialCharsCriteriaMsg}}</span>\n        </div>\n\n        <div class=\"info-row\" @items *ngIf=\"passwordComponent.enableLengthRule\">\n            <div *ngIf=\"passwordComponent.containAtLeastMinChars; then done else error\">\n            </div>\n            <ng-template #done>\n                <mat-icon @positiveState color=\"primary\" svgIcon=\"mat_outline:done\"></mat-icon>\n            </ng-template>\n            <ng-template #error>\n                <mat-icon @negativeState color=\"warn\" svgIcon=\"mat_outline:error\"></mat-icon>\n            </ng-template>\n            <span>{{minCharsCriteriaMsg}}</span>\n        </div>\n\n        <div class=\"info-row\" @items *ngIf=\"passwordComponent.customValidator\">\n            <div *ngIf=\"passwordComponent.containAtCustomChars; then done else error\">\n            </div>\n            <ng-template #done>\n                <mat-icon @positiveState color=\"primary\" svgIcon=\"mat_outline:done\"></mat-icon>\n            </ng-template>\n            <ng-template #error>\n                <mat-icon @negativeState color=\"warn\" svgIcon=\"mat_outline:error\"></mat-icon>\n            </ng-template>\n            <span>{{customCharsCriteriaMsg}}</span>\n        </div>\n\n        <div *ngIf=\"enableScoreInfo\" class=\"info-row\" @items>\n            <div *ngIf=\"passwordComponent.strength === 100; then done else error\">\n            </div>\n            <ng-template #done>\n                <mat-icon @positiveState color=\"primary\" svgIcon=\"mat_outline:done\"></mat-icon>\n            </ng-template>\n            <ng-template #error>\n                <mat-icon @negativeState color=\"warn\" svgIcon=\"mat_outline:error\"></mat-icon>\n            </ng-template>\n            <span>\u5BC6\u7801\u5F3A\u5EA6= {{passwordComponent.strength}} %100</span>\n        </div>\n\n    </mat-card-content>\n</mat-card>", styles: ["cmat-password-strength-info{margin-top:20px}cmat-password-strength-info .mat-mdc-card{@apply flex flex-row flex-1 m-2 box-border place-content-stretch items-stretch;}cmat-password-strength-info .mat-mdc-card .mat-mdc-card-content{@apply flex flex-col box-border max-w-full place-content-stretch items-stretch;}cmat-password-strength-info .mat-mdc-card .mat-mdc-card-content .mat-icon{@apply mr-4;}cmat-password-strength-info .mat-mdc-card .mat-mdc-card-content .info-row{@apply flex flex-row box-border items-center;}\n"], dependencies: [{ kind: "ngmodule", type: MatCardModule }, { kind: "component", type: i1.MatCard, selector: "mat-card", inputs: ["appearance"], exportAs: ["matCard"] }, { kind: "directive", type: i1.MatCardContent, selector: "mat-card-content" }, { kind: "directive", type: NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "ngmodule", type: MatIconModule }, { kind: "component", type: i2.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }], animations: [
+            // nice stagger effect when showing existing elements
+            trigger('list', [
+                transition(':enter', [
+                    // child animation selector + stagger
+                    query('@items', stagger(300, animateChild()))
+                ]),
+            ]),
+            trigger('items', [
+                // cubic-bezier for a tiny bouncing feel
+                transition(':enter', [
+                    style({ transform: 'scale(0.5)', opacity: 0 }),
+                    animate('1s cubic-bezier(.8,-0.6,0.2,1.5)', style({ transform: 'scale(1)', opacity: 1 }))
+                ]),
+                transition(':leave', [
+                    style({ transform: 'scale(1)', opacity: 1, height: '*' }),
+                    animate('1s cubic-bezier(.8,-0.6,0.2,1.5)', style({ transform: 'scale(0.5)', opacity: 0, height: '0px', margin: '0px' }))
+                ]),
+            ]),
+            trigger('positiveState', [
+                transition(':enter', [
+                    // eslint-disable-next-line @typescript-eslint/naming-convention
+                    style({ 'backface-visibility': 'visible' }),
+                    animate('{{ timing }}s {{ delay }}s ease-in', keyframes([
+                        style({
+                            opacity: 0,
+                            transform: 'perspective(400px) rotate3d({{ rotateX }}, {{ rotateY }}, 0, 90deg)',
+                            offset: 0,
+                        }),
+                        style({
+                            opacity: 1,
+                            transform: 'perspective(400px) rotate3d({{ rotateX }}, {{ rotateY }}, 0, -20deg)',
+                            offset: 0.4,
+                        }),
+                        style({
+                            transform: 'perspective(400px) rotate3d({{ rotateX }}, {{ rotateY }}, 0, 10deg)',
+                            offset: 0.6,
+                        }),
+                        style({
+                            transform: 'perspective(400px) rotate3d({{ rotateX }}, {{ rotateY }}, 0, -5deg)',
+                            offset: 0.8,
+                        }),
+                        style({
+                            transform: 'perspective(400px) rotate3d(0, 0, 0, 0)',
+                            offset: 1,
+                        }),
+                    ])),
+                ], { params: { timing: 1, delay: 0, rotateX: 1, rotateY: 0 } }),
+            ]),
+            trigger('negativeState', [
+                transition(':enter', useAnimation(shake)),
+            ]),
+        ], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.0", ngImport: i0, type: CmatPasswordStrengthInfoComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'cmat-password-strength-info', exportAs: 'cmatPasswordStrengthInfo', encapsulation: ViewEncapsulation.None, changeDetection: ChangeDetectionStrategy.OnPush, animations: [
+                        // nice stagger effect when showing existing elements
+                        trigger('list', [
+                            transition(':enter', [
+                                // child animation selector + stagger
+                                query('@items', stagger(300, animateChild()))
+                            ]),
+                        ]),
+                        trigger('items', [
+                            // cubic-bezier for a tiny bouncing feel
+                            transition(':enter', [
+                                style({ transform: 'scale(0.5)', opacity: 0 }),
+                                animate('1s cubic-bezier(.8,-0.6,0.2,1.5)', style({ transform: 'scale(1)', opacity: 1 }))
+                            ]),
+                            transition(':leave', [
+                                style({ transform: 'scale(1)', opacity: 1, height: '*' }),
+                                animate('1s cubic-bezier(.8,-0.6,0.2,1.5)', style({ transform: 'scale(0.5)', opacity: 0, height: '0px', margin: '0px' }))
+                            ]),
+                        ]),
+                        trigger('positiveState', [
+                            transition(':enter', [
+                                // eslint-disable-next-line @typescript-eslint/naming-convention
+                                style({ 'backface-visibility': 'visible' }),
+                                animate('{{ timing }}s {{ delay }}s ease-in', keyframes([
+                                    style({
+                                        opacity: 0,
+                                        transform: 'perspective(400px) rotate3d({{ rotateX }}, {{ rotateY }}, 0, 90deg)',
+                                        offset: 0,
+                                    }),
+                                    style({
+                                        opacity: 1,
+                                        transform: 'perspective(400px) rotate3d({{ rotateX }}, {{ rotateY }}, 0, -20deg)',
+                                        offset: 0.4,
+                                    }),
+                                    style({
+                                        transform: 'perspective(400px) rotate3d({{ rotateX }}, {{ rotateY }}, 0, 10deg)',
+                                        offset: 0.6,
+                                    }),
+                                    style({
+                                        transform: 'perspective(400px) rotate3d({{ rotateX }}, {{ rotateY }}, 0, -5deg)',
+                                        offset: 0.8,
+                                    }),
+                                    style({
+                                        transform: 'perspective(400px) rotate3d(0, 0, 0, 0)',
+                                        offset: 1,
+                                    }),
+                                ])),
+                            ], { params: { timing: 1, delay: 0, rotateX: 1, rotateY: 0 } }),
+                        ]),
+                        trigger('negativeState', [
+                            transition(':enter', useAnimation(shake)),
+                        ]),
+                    ], standalone: true, imports: [MatCardModule, NgIf, MatIconModule], template: "<mat-card @list class=\"info-card\">\n    <mat-card-content>\n        <div class=\"info-row\" @items *ngIf=\"passwordComponent.enableLowerCaseLetterRule\">\n            <div *ngIf=\"passwordComponent.containAtLeastOneLowerCaseLetter; then done else error\" @flipY>\n            </div>\n            <ng-template #done>\n                <mat-icon @positiveState color=\"primary\" svgIcon=\"mat_outline:done\"></mat-icon>\n            </ng-template>\n            <ng-template #error>\n                <mat-icon @negativeState color=\"warn\" svgIcon=\"mat_outline:error\"></mat-icon>\n            </ng-template>\n            <span>{{lowerCaseCriteriaMsg}}</span>\n        </div>\n\n        <div class=\"info-row\" @items *ngIf=\"passwordComponent.enableUpperCaseLetterRule\">\n            <div *ngIf=\"passwordComponent.containAtLeastOneUpperCaseLetter; then done else error\">\n            </div>\n            <ng-template #done>\n                <mat-icon @positiveState color=\"primary\" svgIcon=\"mat_outline:done\"></mat-icon>\n            </ng-template>\n            <ng-template #error>\n                <mat-icon @negativeState color=\"warn\" svgIcon=\"mat_outline:error\"></mat-icon>\n            </ng-template>\n            <span>{{upperCaseCriteriaMsg}}</span>\n        </div>\n\n        <div class=\"info-row\" @items *ngIf=\"passwordComponent.enableDigitRule\">\n            <div *ngIf=\"passwordComponent.containAtLeastOneDigit; then done else error\">\n            </div>\n            <ng-template #done>\n                <mat-icon @positiveState color=\"primary\" svgIcon=\"mat_outline:done\"></mat-icon>\n            </ng-template>\n            <ng-template #error>\n                <mat-icon @negativeState color=\"warn\" svgIcon=\"mat_outline:error\"></mat-icon>\n            </ng-template>\n            <span>{{digitsCriteriaMsg}}</span>\n        </div>\n\n        <div class=\"info-row\" @items *ngIf=\"passwordComponent.enableSpecialCharRule\">\n            <div *ngIf=\"passwordComponent.containAtLeastOneSpecialChar; then done else error\">\n            </div>\n            <ng-template #done>\n                <mat-icon @positiveState color=\"primary\" svgIcon=\"mat_outline:done\"></mat-icon>\n            </ng-template>\n            <ng-template #error>\n                <mat-icon @negativeState color=\"warn\" svgIcon=\"mat_outline:error\"></mat-icon>\n            </ng-template>\n            <span>{{specialCharsCriteriaMsg}}</span>\n        </div>\n\n        <div class=\"info-row\" @items *ngIf=\"passwordComponent.enableLengthRule\">\n            <div *ngIf=\"passwordComponent.containAtLeastMinChars; then done else error\">\n            </div>\n            <ng-template #done>\n                <mat-icon @positiveState color=\"primary\" svgIcon=\"mat_outline:done\"></mat-icon>\n            </ng-template>\n            <ng-template #error>\n                <mat-icon @negativeState color=\"warn\" svgIcon=\"mat_outline:error\"></mat-icon>\n            </ng-template>\n            <span>{{minCharsCriteriaMsg}}</span>\n        </div>\n\n        <div class=\"info-row\" @items *ngIf=\"passwordComponent.customValidator\">\n            <div *ngIf=\"passwordComponent.containAtCustomChars; then done else error\">\n            </div>\n            <ng-template #done>\n                <mat-icon @positiveState color=\"primary\" svgIcon=\"mat_outline:done\"></mat-icon>\n            </ng-template>\n            <ng-template #error>\n                <mat-icon @negativeState color=\"warn\" svgIcon=\"mat_outline:error\"></mat-icon>\n            </ng-template>\n            <span>{{customCharsCriteriaMsg}}</span>\n        </div>\n\n        <div *ngIf=\"enableScoreInfo\" class=\"info-row\" @items>\n            <div *ngIf=\"passwordComponent.strength === 100; then done else error\">\n            </div>\n            <ng-template #done>\n                <mat-icon @positiveState color=\"primary\" svgIcon=\"mat_outline:done\"></mat-icon>\n            </ng-template>\n            <ng-template #error>\n                <mat-icon @negativeState color=\"warn\" svgIcon=\"mat_outline:error\"></mat-icon>\n            </ng-template>\n            <span>\u5BC6\u7801\u5F3A\u5EA6= {{passwordComponent.strength}} %100</span>\n        </div>\n\n    </mat-card-content>\n</mat-card>", styles: ["cmat-password-strength-info{margin-top:20px}cmat-password-strength-info .mat-mdc-card{@apply flex flex-row flex-1 m-2 box-border place-content-stretch items-stretch;}cmat-password-strength-info .mat-mdc-card .mat-mdc-card-content{@apply flex flex-col box-border max-w-full place-content-stretch items-stretch;}cmat-password-strength-info .mat-mdc-card .mat-mdc-card-content .mat-icon{@apply mr-4;}cmat-password-strength-info .mat-mdc-card .mat-mdc-card-content .info-row{@apply flex flex-row box-border items-center;}\n"] }]
+        }], propDecorators: { passwordComponent: [{
+                type: Input
+            }], enableScoreInfo: [{
+                type: Input
+            }], lowerCaseCriteriaMsg: [{
+                type: Input
+            }], upperCaseCriteriaMsg: [{
+                type: Input
+            }], digitsCriteriaMsg: [{
+                type: Input
+            }], specialCharsCriteriaMsg: [{
+                type: Input
+            }], customCharsCriteriaMsg: [{
+                type: Input
+            }], minCharsCriteriaMsg: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"mat-password-strength-info.component.js","sourceRoot":"","sources":["../../../../../../projects/cmat/components/password-strength/mat-password-strength-info/mat-password-strength-info.component.ts","../../../../../../projects/cmat/components/password-strength/mat-password-strength-info/mat-password-strength-info.component.html"],"names":[],"mappings":"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","sourcesContent":["import { ChangeDetectionStrategy, Component, Input, OnInit, ViewEncapsulation } from '@angular/core';\r\nimport { CmatPasswordStrengthComponent } from '../mat-password-strength/mat-password-strength.component';\r\nimport { animate, animateChild, keyframes, query, stagger, style, transition, trigger, useAnimation } from '@angular/animations';\r\nimport { MatIconModule } from '@angular/material/icon';\r\nimport { NgIf } from '@angular/common';\r\nimport { MatCardModule } from '@angular/material/card';\r\nimport { shake } from '../animations'\r\n\r\n@Component({\r\n    selector: 'cmat-password-strength-info',\r\n    exportAs: 'cmatPasswordStrengthInfo',\r\n    templateUrl: './mat-password-strength-info.component.html',\r\n    styleUrls: ['./mat-password-strength-info.component.scss'],\r\n    encapsulation: ViewEncapsulation.None,\r\n    changeDetection: ChangeDetectionStrategy.OnPush,\r\n    animations: [\r\n        // nice stagger effect when showing existing elements\r\n        trigger('list', [\r\n            transition(':enter', [\r\n                // child animation selector + stagger\r\n                query('@items', stagger(300, animateChild()))\r\n            ]),\r\n        ]),\r\n        trigger('items', [\r\n            // cubic-bezier for a tiny bouncing feel\r\n            transition(':enter', [\r\n                style({ transform: 'scale(0.5)', opacity: 0 }),\r\n                animate('1s cubic-bezier(.8,-0.6,0.2,1.5)', style({ transform: 'scale(1)', opacity: 1 }))\r\n            ]),\r\n            transition(':leave', [\r\n                style({ transform: 'scale(1)', opacity: 1, height: '*' }),\r\n                animate('1s cubic-bezier(.8,-0.6,0.2,1.5)', style({ transform: 'scale(0.5)', opacity: 0, height: '0px', margin: '0px' }))\r\n            ]),\r\n        ]),\r\n        trigger('positiveState', [\r\n            transition(':enter', [\r\n                // eslint-disable-next-line @typescript-eslint/naming-convention\r\n                style({ 'backface-visibility': 'visible' }),\r\n                animate('{{ timing }}s {{ delay }}s ease-in', keyframes([\r\n                    style({\r\n                        opacity: 0,\r\n                        transform: 'perspective(400px) rotate3d({{ rotateX }}, {{ rotateY }}, 0, 90deg)',\r\n                        offset: 0,\r\n                    }),\r\n                    style({\r\n                        opacity: 1,\r\n                        transform: 'perspective(400px) rotate3d({{ rotateX }}, {{ rotateY }}, 0, -20deg)',\r\n                        offset: 0.4,\r\n                    }),\r\n                    style({\r\n                        transform: 'perspective(400px) rotate3d({{ rotateX }}, {{ rotateY }}, 0, 10deg)',\r\n                        offset: 0.6,\r\n                    }),\r\n                    style({\r\n                        transform: 'perspective(400px) rotate3d({{ rotateX }}, {{ rotateY }}, 0, -5deg)',\r\n                        offset: 0.8,\r\n                    }),\r\n                    style({\r\n                        transform: 'perspective(400px) rotate3d(0, 0, 0, 0)',\r\n                        offset: 1,\r\n                    }),\r\n                ])),\r\n            ], { params: { timing: 1, delay: 0, rotateX: 1, rotateY: 0 } }),\r\n        ]),\r\n        trigger('negativeState', [\r\n            transition(':enter', useAnimation(shake)),\r\n        ]),\r\n    ],\r\n    standalone: true,\r\n    imports: [MatCardModule, NgIf, MatIconModule]\r\n})\r\nexport class CmatPasswordStrengthInfoComponent implements OnInit {\r\n\r\n    @Input()\r\n    passwordComponent: CmatPasswordStrengthComponent;\r\n\r\n    @Input()\r\n    enableScoreInfo = false;\r\n\r\n    @Input()\r\n    lowerCaseCriteriaMsg = '包含至少一个小写字母';\r\n\r\n    @Input()\r\n    upperCaseCriteriaMsg = '包含至少一个大写字母';\r\n\r\n    @Input()\r\n    digitsCriteriaMsg = '包含至少一个数字';\r\n\r\n    @Input()\r\n    specialCharsCriteriaMsg = '包含至少一个特殊字符';\r\n\r\n    @Input()\r\n    customCharsCriteriaMsg = '包含至少一个传统字符';\r\n\r\n    @Input()\r\n    minCharsCriteriaMsg: string;\r\n\r\n    ngOnInit(): void {\r\n        if (!this.minCharsCriteriaMsg) {\r\n            this.minCharsCriteriaMsg = `包含至少 ${this.passwordComponent.min} 个字符`;\r\n        }\r\n    }\r\n\r\n}\r\n","<mat-card @list class=\"info-card\">\n    <mat-card-content>\n        <div class=\"info-row\" @items *ngIf=\"passwordComponent.enableLowerCaseLetterRule\">\n            <div *ngIf=\"passwordComponent.containAtLeastOneLowerCaseLetter; then done else error\" @flipY>\n            </div>\n            <ng-template #done>\n                <mat-icon @positiveState color=\"primary\" svgIcon=\"mat_outline:done\"></mat-icon>\n            </ng-template>\n            <ng-template #error>\n                <mat-icon @negativeState color=\"warn\" svgIcon=\"mat_outline:error\"></mat-icon>\n            </ng-template>\n            <span>{{lowerCaseCriteriaMsg}}</span>\n        </div>\n\n        <div class=\"info-row\" @items *ngIf=\"passwordComponent.enableUpperCaseLetterRule\">\n            <div *ngIf=\"passwordComponent.containAtLeastOneUpperCaseLetter; then done else error\">\n            </div>\n            <ng-template #done>\n                <mat-icon @positiveState color=\"primary\" svgIcon=\"mat_outline:done\"></mat-icon>\n            </ng-template>\n            <ng-template #error>\n                <mat-icon @negativeState color=\"warn\" svgIcon=\"mat_outline:error\"></mat-icon>\n            </ng-template>\n            <span>{{upperCaseCriteriaMsg}}</span>\n        </div>\n\n        <div class=\"info-row\" @items *ngIf=\"passwordComponent.enableDigitRule\">\n            <div *ngIf=\"passwordComponent.containAtLeastOneDigit; then done else error\">\n            </div>\n            <ng-template #done>\n                <mat-icon @positiveState color=\"primary\" svgIcon=\"mat_outline:done\"></mat-icon>\n            </ng-template>\n            <ng-template #error>\n                <mat-icon @negativeState color=\"warn\" svgIcon=\"mat_outline:error\"></mat-icon>\n            </ng-template>\n            <span>{{digitsCriteriaMsg}}</span>\n        </div>\n\n        <div class=\"info-row\" @items *ngIf=\"passwordComponent.enableSpecialCharRule\">\n            <div *ngIf=\"passwordComponent.containAtLeastOneSpecialChar; then done else error\">\n            </div>\n            <ng-template #done>\n                <mat-icon @positiveState color=\"primary\" svgIcon=\"mat_outline:done\"></mat-icon>\n            </ng-template>\n            <ng-template #error>\n                <mat-icon @negativeState color=\"warn\" svgIcon=\"mat_outline:error\"></mat-icon>\n            </ng-template>\n            <span>{{specialCharsCriteriaMsg}}</span>\n        </div>\n\n        <div class=\"info-row\" @items *ngIf=\"passwordComponent.enableLengthRule\">\n            <div *ngIf=\"passwordComponent.containAtLeastMinChars; then done else error\">\n            </div>\n            <ng-template #done>\n                <mat-icon @positiveState color=\"primary\" svgIcon=\"mat_outline:done\"></mat-icon>\n            </ng-template>\n            <ng-template #error>\n                <mat-icon @negativeState color=\"warn\" svgIcon=\"mat_outline:error\"></mat-icon>\n            </ng-template>\n            <span>{{minCharsCriteriaMsg}}</span>\n        </div>\n\n        <div class=\"info-row\" @items *ngIf=\"passwordComponent.customValidator\">\n            <div *ngIf=\"passwordComponent.containAtCustomChars; then done else error\">\n            </div>\n            <ng-template #done>\n                <mat-icon @positiveState color=\"primary\" svgIcon=\"mat_outline:done\"></mat-icon>\n            </ng-template>\n            <ng-template #error>\n                <mat-icon @negativeState color=\"warn\" svgIcon=\"mat_outline:error\"></mat-icon>\n            </ng-template>\n            <span>{{customCharsCriteriaMsg}}</span>\n        </div>\n\n        <div *ngIf=\"enableScoreInfo\" class=\"info-row\" @items>\n            <div *ngIf=\"passwordComponent.strength === 100; then done else error\">\n            </div>\n            <ng-template #done>\n                <mat-icon @positiveState color=\"primary\" svgIcon=\"mat_outline:done\"></mat-icon>\n            </ng-template>\n            <ng-template #error>\n                <mat-icon @negativeState color=\"warn\" svgIcon=\"mat_outline:error\"></mat-icon>\n            </ng-template>\n            <span>密码强度= {{passwordComponent.strength}} %100</span>\n        </div>\n\n    </mat-card-content>\n</mat-card>"]}