@alauda-fe/common 1.0.0-hotfix-znx-3.16.1-1

package/esm2022/core/directives/intercept-deactivate.directive.mjs

@@ -0,0 +1,52 @@
+import { __decorate, __metadata } from "tslib";
+import { coerceAttrBoolean } from '@alauda/ui';
+import { Directive, ElementRef, HostListener, Input, isDevMode, } from '@angular/core';
+import { fromEvent, map, Observable, Subject, takeUntil, withLatestFrom, } from 'rxjs';
+import { InterceptDeactivateService } from '../services/intercept-deactivate.service';
+import { ObservableInput } from '../utils/decorators';
+import * as i0 from "@angular/core";
+import * as i1 from "../services/intercept-deactivate.service";
+export class InterceptDeactivateDirective {
+    constructor(elRef, interceptDeactivate) {
+        this.elRef = elRef;
+        this.interceptDeactivate = interceptDeactivate;
+        this.enabled$ = this.enabled$$.pipe(map(coerceAttrBoolean));
+        this.destroy$$ = new Subject();
+    }
+    ngAfterViewInit() {
+        fromEvent(this.elRef.nativeElement, 'click')
+            .pipe(withLatestFrom(this.enabled$), takeUntil(this.destroy$$))
+            .subscribe(([, enabled]) => {
+            this.interceptDeactivate.back(!enabled);
+        });
+    }
+    ngOnDestroy() {
+        this.destroy$$.next();
+        this.destroy$$.complete();
+    }
+    onBeforeUnload() {
+        return isDevMode() || !this.enabled;
+    }
+    static { this.ɵfac = function InterceptDeactivateDirective_Factory(t) { return new (t || InterceptDeactivateDirective)(i0.ɵɵdirectiveInject(i0.ElementRef), i0.ɵɵdirectiveInject(i1.InterceptDeactivateService)); }; }
+    static { this.ɵdir = /*@__PURE__*/ i0.ɵɵdefineDirective({ type: InterceptDeactivateDirective, selectors: [["", "aclInterceptDeactivate", ""]], hostBindings: function InterceptDeactivateDirective_HostBindings(rf, ctx) { if (rf & 1) {
+            i0.ɵɵlistener("beforeunload", function InterceptDeactivateDirective_beforeunload_HostBindingHandler() { return ctx.onBeforeUnload(); }, false, i0.ɵɵresolveWindow);
+        } }, inputs: { enabled: ["aclInterceptDeactivate", "enabled"] }, standalone: true }); }
+}
+__decorate([
+    ObservableInput(),
+    __metadata("design:type", Observable)
+], InterceptDeactivateDirective.prototype, "enabled$$", void 0);
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(InterceptDeactivateDirective, [{
+        type: Directive,
+        args: [{
+                selector: '[aclInterceptDeactivate]',
+                standalone: true,
+            }]
+    }], function () { return [{ type: i0.ElementRef }, { type: i1.InterceptDeactivateService }]; }, { enabled: [{
+            type: Input,
+            args: ['aclInterceptDeactivate']
+        }], enabled$$: [], onBeforeUnload: [{
+            type: HostListener,
+            args: ['window:beforeunload']
+        }] }); })();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/core/directives/last-form-item.directive.mjs

@@ -0,0 +1,18 @@
+import { Directive, ElementRef } from '@angular/core';
+import * as i0 from "@angular/core";
+export class FormItemMarginEffectDirective {
+    constructor(el) {
+        this.el = el;
+        this.el.nativeElement.style.display = 'block';
+        this.el.nativeElement.style.marginBottom = '-16px';
+    }
+    static { this.ɵfac = function FormItemMarginEffectDirective_Factory(t) { return new (t || FormItemMarginEffectDirective)(i0.ɵɵdirectiveInject(i0.ElementRef)); }; }
+    static { this.ɵdir = /*@__PURE__*/ i0.ɵɵdefineDirective({ type: FormItemMarginEffectDirective, selectors: [["", "aclFormItemEffect", ""]] }); }
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(FormItemMarginEffectDirective, [{
+        type: Directive,
+        args: [{
+                selector: '[aclFormItemEffect]',
+            }]
+    }], function () { return [{ type: i0.ElementRef }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibGFzdC1mb3JtLWl0ZW0uZGlyZWN0aXZlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9jb21tb24vc3JjL2NvcmUvZGlyZWN0aXZlcy9sYXN0LWZvcm0taXRlbS5kaXJlY3RpdmUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFNBQVMsRUFBRSxVQUFVLEVBQUUsTUFBTSxlQUFlLENBQUM7O0FBS3RELE1BQU0sT0FBTyw2QkFBNkI7SUFDeEMsWUFBNkIsRUFBYztRQUFkLE9BQUUsR0FBRixFQUFFLENBQVk7UUFDekMsSUFBSSxDQUFDLEVBQUUsQ0FBQyxhQUFhLENBQUMsS0FBSyxDQUFDLE9BQU8sR0FBRyxPQUFPLENBQUM7UUFDOUMsSUFBSSxDQUFDLEVBQUUsQ0FBQyxhQUFhLENBQUMsS0FBSyxDQUFDLFlBQVksR0FBRyxPQUFPLENBQUM7SUFDckQsQ0FBQzs4RkFKVSw2QkFBNkI7b0VBQTdCLDZCQUE2Qjs7dUZBQTdCLDZCQUE2QjtjQUh6QyxTQUFTO2VBQUM7Z0JBQ1QsUUFBUSxFQUFFLHFCQUFxQjthQUNoQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IERpcmVjdGl2ZSwgRWxlbWVudFJlZiB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuXG5ARGlyZWN0aXZlKHtcbiAgc2VsZWN0b3I6ICdbYWNsRm9ybUl0ZW1FZmZlY3RdJyxcbn0pXG5leHBvcnQgY2xhc3MgRm9ybUl0ZW1NYXJnaW5FZmZlY3REaXJlY3RpdmUge1xuICBjb25zdHJ1Y3Rvcihwcml2YXRlIHJlYWRvbmx5IGVsOiBFbGVtZW50UmVmKSB7XG4gICAgdGhpcy5lbC5uYXRpdmVFbGVtZW50LnN0eWxlLmRpc3BsYXkgPSAnYmxvY2snO1xuICAgIHRoaXMuZWwubmF0aXZlRWxlbWVudC5zdHlsZS5tYXJnaW5Cb3R0b20gPSAnLTE2cHgnO1xuICB9XG59XG4iXX0=

package/esm2022/core/directives/page-header-content.directive.mjs

@@ -0,0 +1,41 @@
+import { TemplatePortal } from '@angular/cdk/portal';
+import { Directive, TemplateRef, ViewContainerRef, } from '@angular/core';
+import { TemplateHolderType, UiStateService, } from '../services/ui-state.service';
+import * as i0 from "@angular/core";
+import * as i1 from "../services/ui-state.service";
+/**
+ * Dynamically change page header content based on active template.
+ *
+ * Usage:
+ * If you want to customize a page header, wrap a template with *aclPageHeaderContent.
+ *
+ * eg:
+ * <ng-container *aclPageHeaderContent>
+ *   ... YOUR TEMPLATE CONTENT
+ * </ng-container>
+ */
+export class PageHeaderContentDirective {
+    constructor(templateRef, viewContainerRef, uiState) {
+        this.templateRef = templateRef;
+        this.viewContainerRef = viewContainerRef;
+        this.uiState = uiState;
+        this.templateHolder = this.uiState.getTemplateHolder(TemplateHolderType.PageHeaderContent);
+    }
+    ngOnInit() {
+        const portal = new TemplatePortal(this.templateRef, this.viewContainerRef);
+        this.templateHolder.setTemplatePortal(portal);
+    }
+    ngOnDestroy() {
+        this.templateHolder.setTemplatePortal(null);
+    }
+    static { this.ɵfac = function PageHeaderContentDirective_Factory(t) { return new (t || PageHeaderContentDirective)(i0.ɵɵdirectiveInject(i0.TemplateRef), i0.ɵɵdirectiveInject(i0.ViewContainerRef), i0.ɵɵdirectiveInject(i1.UiStateService)); }; }
+    static { this.ɵdir = /*@__PURE__*/ i0.ɵɵdefineDirective({ type: PageHeaderContentDirective, selectors: [["", "aclPageHeaderContent", ""]], standalone: true }); }
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(PageHeaderContentDirective, [{
+        type: Directive,
+        args: [{
+                selector: '[aclPageHeaderContent]',
+                standalone: true,
+            }]
+    }], function () { return [{ type: i0.TemplateRef }, { type: i0.ViewContainerRef }, { type: i1.UiStateService }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/core/directives/public-api.mjs

@@ -0,0 +1,11 @@
+export * from './disabled.directive';
+export * from './feature-gate.directive';
+export * from './intercept-deactivate.directive';
+export * from './last-form-item.directive';
+export * from './page-header-content.directive';
+export * from './readonly-field.directive';
+export * from './resize.directive';
+export * from './scroll-to-first-invalid.directive';
+export * from './scroll-border-observer.directive';
+export * from './click-outside.directive';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvY29tbW9uL3NyYy9jb3JlL2RpcmVjdGl2ZXMvcHVibGljLWFwaS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLHNCQUFzQixDQUFDO0FBQ3JDLGNBQWMsMEJBQTBCLENBQUM7QUFDekMsY0FBYyxrQ0FBa0MsQ0FBQztBQUNqRCxjQUFjLDRCQUE0QixDQUFDO0FBQzNDLGNBQWMsaUNBQWlDLENBQUM7QUFDaEQsY0FBYyw0QkFBNEIsQ0FBQztBQUMzQyxjQUFjLG9CQUFvQixDQUFDO0FBQ25DLGNBQWMscUNBQXFDLENBQUM7QUFDcEQsY0FBYyxvQ0FBb0MsQ0FBQztBQUNuRCxjQUFjLDJCQUEyQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9kaXNhYmxlZC5kaXJlY3RpdmUnO1xuZXhwb3J0ICogZnJvbSAnLi9mZWF0dXJlLWdhdGUuZGlyZWN0aXZlJztcbmV4cG9ydCAqIGZyb20gJy4vaW50ZXJjZXB0LWRlYWN0aXZhdGUuZGlyZWN0aXZlJztcbmV4cG9ydCAqIGZyb20gJy4vbGFzdC1mb3JtLWl0ZW0uZGlyZWN0aXZlJztcbmV4cG9ydCAqIGZyb20gJy4vcGFnZS1oZWFkZXItY29udGVudC5kaXJlY3RpdmUnO1xuZXhwb3J0ICogZnJvbSAnLi9yZWFkb25seS1maWVsZC5kaXJlY3RpdmUnO1xuZXhwb3J0ICogZnJvbSAnLi9yZXNpemUuZGlyZWN0aXZlJztcbmV4cG9ydCAqIGZyb20gJy4vc2Nyb2xsLXRvLWZpcnN0LWludmFsaWQuZGlyZWN0aXZlJztcbmV4cG9ydCAqIGZyb20gJy4vc2Nyb2xsLWJvcmRlci1vYnNlcnZlci5kaXJlY3RpdmUnO1xuZXhwb3J0ICogZnJvbSAnLi9jbGljay1vdXRzaWRlLmRpcmVjdGl2ZSc7XG4iXX0=

package/esm2022/core/directives/readonly-field.directive.mjs

@@ -0,0 +1,157 @@
+import { __decorate, __metadata } from "tslib";
+/**
+ * @packageDocumentation
+ * @module utils
+ */
+import { FormItemControlDirective } from '@alauda/ui';
+import { CdkPortalOutlet, ComponentPortal, TemplatePortal, } from '@angular/cdk/portal';
+import { ChangeDetectionStrategy, Component, ComponentFactoryResolver, Directive, HostBinding, Input, Optional, Self, TemplateRef, ViewContainerRef, } from '@angular/core';
+import { NgControl, } from '@angular/forms';
+import { Observable, Subject, combineLatest, distinctUntilChanged, filter, map, startWith, takeUntil, } from 'rxjs';
+import { ObservableInput } from '../utils/decorators';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/forms";
+import * as i2 from "@alauda/ui";
+import * as i3 from "../pipes/field-not-available.pipe";
+export class ReadonlyFieldDirective {
+    get isHidden() {
+        return this.hidden || this.aclReadonlyField;
+    }
+    constructor(control, 
+    // eslint-disable-next-line sonar/deprecation
+    cfr, viewContainerRef, 
+    // 仅考虑当前control，子control无法知晓父FormItemControl元素 ，包裹了多少个control，以及各自处于什么状态，该情况自行处理
+    controlDirective) {
+        this.control = control;
+        this.cfr = cfr;
+        this.viewContainerRef = viewContainerRef;
+        this.controlDirective = controlDirective;
+        this.isControlRequired = false;
+        this.templateContext = {};
+        this.destroy$ = new Subject();
+    }
+    setValue(value) {
+        if (this.template) {
+            Object.assign(this.templateContext, {
+                $implicit: value,
+                ...this.context,
+            });
+        }
+        else {
+            this.spanComponentRef.instance.setData(value);
+        }
+    }
+    ngOnInit() {
+        const controlEntity = this.control.control;
+        // formControl will compose multi validators to 1, no matter defined in template nor FormBuilder
+        const { validator, asyncValidator } = controlEntity;
+        this.isControlRequired = this.controlDirective?.required || false;
+        const portalOutlet = new CdkPortalOutlet(this.cfr, this.viewContainerRef);
+        const portal = this.template
+            ? new TemplatePortal(this.template, this.viewContainerRef, this.templateContext)
+            : new ComponentPortal(SpanComponent, this.viewContainerRef);
+        const containerAttached$ = this.aclReadonlyField$.pipe(distinctUntilChanged(), map(isUpdate => {
+            if (!isUpdate) {
+                // 重置
+                if (this.controlDirective) {
+                    this.controlDirective.required = this.isControlRequired;
+                }
+                if (portalOutlet.hasAttached()) {
+                    portalOutlet.detach();
+                }
+                this.applyValidators(controlEntity, validator, asyncValidator);
+                return false;
+            }
+            if (this.controlDirective) {
+                this.controlDirective.required = false;
+            }
+            const attachPoint = portalOutlet.attach(portal);
+            if (!this.template) {
+                this.spanComponentRef = attachPoint;
+            }
+            this.clearValidators(controlEntity);
+            return true;
+        }));
+        const sourceValue$ = this.control.valueChanges.pipe(startWith(this.control.value));
+        combineLatest([sourceValue$, containerAttached$])
+            .pipe(takeUntil(this.destroy$), filter(([, attached]) => !!attached))
+            .subscribe(([value]) => {
+            this.setValue(value);
+        });
+    }
+    applyValidators(control, rawValidator, rawAsyncValidator) {
+        if (control.validator === rawValidator &&
+            control.asyncValidator === rawAsyncValidator) {
+            return;
+        }
+        control.setValidators(rawValidator);
+        control.setAsyncValidators(rawAsyncValidator);
+        control.updateValueAndValidity();
+    }
+    clearValidators(control) {
+        // delay checking validators for ngModel
+        requestAnimationFrame(() => {
+            if (!control.validator && !control.asyncValidator) {
+                return;
+            }
+            control.clearValidators();
+            control.clearAsyncValidators();
+            control.updateValueAndValidity();
+        });
+    }
+    ngOnDestroy() {
+        this.destroy$.next();
+    }
+    static { this.ɵfac = function ReadonlyFieldDirective_Factory(t) { return new (t || ReadonlyFieldDirective)(i0.ɵɵdirectiveInject(i1.NgControl), i0.ɵɵdirectiveInject(i0.ComponentFactoryResolver), i0.ɵɵdirectiveInject(i0.ViewContainerRef), i0.ɵɵdirectiveInject(i2.FormItemControlDirective, 10)); }; }
+    static { this.ɵdir = /*@__PURE__*/ i0.ɵɵdefineDirective({ type: ReadonlyFieldDirective, selectors: [["", "aclReadonlyField", ""]], hostVars: 1, hostBindings: function ReadonlyFieldDirective_HostBindings(rf, ctx) { if (rf & 2) {
+            i0.ɵɵhostProperty("hidden", ctx.isHidden);
+        } }, inputs: { aclReadonlyField: "aclReadonlyField", hidden: "hidden", template: ["aclReadonlyFieldTemplate", "template"], context: ["aclReadonlyFieldTemplateContext", "context"] }, standalone: true }); }
+}
+__decorate([
+    ObservableInput(),
+    __metadata("design:type", Observable)
+], ReadonlyFieldDirective.prototype, "aclReadonlyField$", void 0);
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(ReadonlyFieldDirective, [{
+        type: Directive,
+        args: [{
+                selector: '[aclReadonlyField]',
+                standalone: true,
+            }]
+    }], function () { return [{ type: i1.NgControl }, { type: i0.ComponentFactoryResolver }, { type: i0.ViewContainerRef }, { type: i2.FormItemControlDirective, decorators: [{
+                type: Self
+            }, {
+                type: Optional
+            }] }]; }, { aclReadonlyField: [{
+            type: Input
+        }], aclReadonlyField$: [], hidden: [{
+            type: Input
+        }], template: [{
+            type: Input,
+            args: ['aclReadonlyFieldTemplate']
+        }], context: [{
+            type: Input,
+            args: ['aclReadonlyFieldTemplateContext']
+        }], isHidden: [{
+            type: HostBinding,
+            args: ['hidden']
+        }] }); })();
+export class SpanComponent {
+    setData(value) {
+        this.data = value;
+    }
+    static { this.ɵfac = function SpanComponent_Factory(t) { return new (t || SpanComponent)(); }; }
+    static { this.ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: SpanComponent, selectors: [["ng-component"]], decls: 3, vars: 3, template: function SpanComponent_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵelementStart(0, "span");
+            i0.ɵɵtext(1);
+            i0.ɵɵpipe(2, "aclFieldNotAvailable");
+            i0.ɵɵelementEnd();
+        } if (rf & 2) {
+            i0.ɵɵadvance(1);
+            i0.ɵɵtextInterpolate(i0.ɵɵpipeBind1(2, 1, ctx.data));
+        } }, dependencies: [i3.FieldNotAvailablePipe], styles: ["span[_ngcontent-%COMP%]{word-break:break-all}"] }); }
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(SpanComponent, [{
+        type: Component,
+        args: [{ template: `<span>{{ data | aclFieldNotAvailable }}</span>`, changeDetection: ChangeDetectionStrategy.Default, styles: ["span{word-break:break-all}\n"] }]
+    }], null, null); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"readonly-field.directive.js","sourceRoot":"","sources":["../../../../../../libs/common/src/core/directives/readonly-field.directive.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @packageDocumentation\n * @module utils\n */\n\nimport { FormItemControlDirective } from '@alauda/ui';\nimport {\n  CdkPortalOutlet,\n  ComponentPortal,\n  TemplatePortal,\n} from '@angular/cdk/portal';\nimport {\n  ChangeDetectionStrategy,\n  Component,\n  ComponentFactoryResolver,\n  ComponentRef,\n  Directive,\n  HostBinding,\n  Input,\n  OnDestroy,\n  OnInit,\n  Optional,\n  Self,\n  TemplateRef,\n  ViewContainerRef,\n} from '@angular/core';\nimport {\n  AbstractControl,\n  AsyncValidatorFn,\n  NgControl,\n  ValidatorFn,\n} from '@angular/forms';\nimport {\n  Observable,\n  Subject,\n  combineLatest,\n  distinctUntilChanged,\n  filter,\n  map,\n  startWith,\n  takeUntil,\n} from 'rxjs';\n\nimport { ObservableInput } from '../utils/decorators';\n\n@Directive({\n  selector: '[aclReadonlyField]',\n  standalone: true,\n})\nexport class ReadonlyFieldDirective implements OnInit, OnDestroy {\n  @Input()\n  aclReadonlyField: boolean;\n\n  @ObservableInput()\n  aclReadonlyField$: Observable<boolean>;\n\n  @Input()\n  hidden: boolean;\n\n  private isControlRequired = false;\n\n  private spanComponentRef: ComponentRef<SpanComponent>;\n\n  private readonly templateContext = {};\n\n  private readonly destroy$ = new Subject<void>();\n\n  // 自定义模板\n  @Input('aclReadonlyFieldTemplate')\n  template: TemplateRef<any>;\n\n  // 自定义模板\n  // eslint-disable-next-line @angular-eslint/no-input-rename\n  @Input('aclReadonlyFieldTemplateContext')\n  context: object;\n\n  @HostBinding('hidden')\n  get isHidden() {\n    return this.hidden || this.aclReadonlyField;\n  }\n\n  constructor(\n    private readonly control: NgControl,\n    // eslint-disable-next-line sonar/deprecation\n    private readonly cfr: ComponentFactoryResolver,\n    private readonly viewContainerRef: ViewContainerRef,\n    // 仅考虑当前control，子control无法知晓父FormItemControl元素 ，包裹了多少个control，以及各自处于什么状态，该情况自行处理\n    @Self()\n    @Optional()\n    private readonly controlDirective: FormItemControlDirective,\n  ) {}\n\n  private setValue(value: unknown) {\n    if (this.template) {\n      Object.assign(this.templateContext, {\n        $implicit: value,\n        ...this.context,\n      });\n    } else {\n      this.spanComponentRef.instance.setData(value);\n    }\n  }\n\n  ngOnInit() {\n    const controlEntity = this.control.control;\n    // formControl will compose multi validators to 1, no matter defined in template nor FormBuilder\n    const { validator, asyncValidator } = controlEntity;\n    this.isControlRequired = this.controlDirective?.required || false;\n    const portalOutlet = new CdkPortalOutlet(this.cfr, this.viewContainerRef);\n    const portal = this.template\n      ? new TemplatePortal(\n          this.template,\n          this.viewContainerRef,\n          this.templateContext,\n        )\n      : new ComponentPortal(SpanComponent, this.viewContainerRef);\n\n    const containerAttached$ = this.aclReadonlyField$.pipe(\n      distinctUntilChanged(),\n      map(isUpdate => {\n        if (!isUpdate) {\n          // 重置\n          if (this.controlDirective) {\n            this.controlDirective.required = this.isControlRequired;\n          }\n          if (portalOutlet.hasAttached()) {\n            portalOutlet.detach();\n          }\n          this.applyValidators(controlEntity, validator, asyncValidator);\n          return false;\n        }\n\n        if (this.controlDirective) {\n          this.controlDirective.required = false;\n        }\n        const attachPoint = portalOutlet.attach(portal);\n        if (!this.template) {\n          this.spanComponentRef = attachPoint as ComponentRef<SpanComponent>;\n        }\n        this.clearValidators(controlEntity);\n        return true;\n      }),\n    );\n\n    const sourceValue$ = this.control.valueChanges.pipe(\n      startWith(this.control.value),\n    );\n\n    combineLatest([sourceValue$, containerAttached$])\n      .pipe(\n        takeUntil(this.destroy$),\n        filter(([, attached]) => !!attached),\n      )\n      .subscribe(([value]) => {\n        this.setValue(value);\n      });\n  }\n\n  private applyValidators(\n    control: AbstractControl,\n    rawValidator?: ValidatorFn,\n    rawAsyncValidator?: AsyncValidatorFn,\n  ) {\n    if (\n      control.validator === rawValidator &&\n      control.asyncValidator === rawAsyncValidator\n    ) {\n      return;\n    }\n    control.setValidators(rawValidator);\n    control.setAsyncValidators(rawAsyncValidator);\n    control.updateValueAndValidity();\n  }\n\n  private clearValidators(control: AbstractControl) {\n    // delay checking validators for ngModel\n    requestAnimationFrame(() => {\n      if (!control.validator && !control.asyncValidator) {\n        return;\n      }\n      control.clearValidators();\n      control.clearAsyncValidators();\n      control.updateValueAndValidity();\n    });\n  }\n\n  ngOnDestroy() {\n    this.destroy$.next();\n  }\n}\n\n@Component({\n  template: `<span>{{ data | aclFieldNotAvailable }}</span>`,\n  styles: [\n    `\n      span {\n        word-break: break-all;\n      }\n    `,\n  ],\n  // eslint-disable-next-line @angular-eslint/prefer-on-push-component-change-detection\n  changeDetection: ChangeDetectionStrategy.Default,\n})\nexport class SpanComponent<T = unknown> {\n  data: T;\n\n  setData(value: T) {\n    this.data = value;\n  }\n}\n"]}

package/esm2022/core/directives/resize.directive.mjs

@@ -0,0 +1,39 @@
+import { observeResizeOn } from '@alauda/ui';
+import { Directive, ElementRef, EventEmitter, Output, } from '@angular/core';
+import { Subject, takeUntil } from 'rxjs';
+import * as i0 from "@angular/core";
+export class ResizeDirective {
+    constructor(element) {
+        this.element = element;
+        this.resized = new EventEmitter();
+        this.destroy$$ = new Subject();
+    }
+    ngAfterViewInit() {
+        observeResizeOn(this.element.nativeElement)
+            .pipe(takeUntil(this.destroy$$))
+            .subscribe(() => this.onResized());
+    }
+    onResized() {
+        const { clientWidth, clientHeight } = this.element.nativeElement;
+        this.resized.emit({
+            width: clientWidth,
+            height: clientHeight,
+        });
+    }
+    ngOnDestroy() {
+        this.destroy$$.next();
+        this.destroy$$.complete();
+    }
+    static { this.ɵfac = function ResizeDirective_Factory(t) { return new (t || ResizeDirective)(i0.ɵɵdirectiveInject(i0.ElementRef)); }; }
+    static { this.ɵdir = /*@__PURE__*/ i0.ɵɵdefineDirective({ type: ResizeDirective, selectors: [["", "aclResize", ""]], outputs: { resized: "resized" }, standalone: true }); }
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(ResizeDirective, [{
+        type: Directive,
+        args: [{
+                selector: '[aclResize]',
+                standalone: true,
+            }]
+    }], function () { return [{ type: i0.ElementRef }]; }, { resized: [{
+            type: Output
+        }] }); })();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/core/directives/scroll-border-observer.directive.mjs

@@ -0,0 +1,77 @@
+import { observeResizeOn } from '@alauda/ui';
+import { ScrollDispatcher } from '@angular/cdk/overlay';
+import { Directive, EventEmitter, Injector, Input, Output, ViewContainerRef, } from '@angular/core';
+import { debounceTime, fromEvent, map, pairwise, startWith, Subject, takeUntil, merge, } from 'rxjs';
+import * as i0 from "@angular/core";
+const defaultDistance = 60;
+// 监测滚动到边界并触发回调
+export class ScrollBorderObserverDirective {
+    constructor(injector) {
+        this.scrollBorder = new EventEmitter();
+        this.scrollBottomBorder = new EventEmitter();
+        this.destroy$$ = new Subject();
+        this.scrollDispatcher = injector.get(ScrollDispatcher);
+        this.viewContainerRef = injector.get(ViewContainerRef);
+    }
+    ngOnInit() {
+        if (this.option === false) {
+            return;
+        }
+        this.scrollEl =
+            this.scrollDispatcher
+                .getAncestorScrollContainers(this.viewContainerRef.element.nativeElement)
+                .pop()
+                ?.getElementRef()?.nativeElement ?? window;
+        this.setupScroll();
+    }
+    ngOnDestroy() {
+        this.destroy$$.next();
+        this.destroy$$.complete();
+    }
+    setupScroll() {
+        const viewEl = this.scrollEl === window
+            ? document.documentElement
+            : this.scrollEl;
+        merge(observeResizeOn(viewEl), fromEvent(this.scrollEl, 'scroll').pipe(startWith(viewEl.scrollTop)))
+            .pipe(debounceTime(50), map(() => viewEl.scrollTop), pairwise(), takeUntil(this.destroy$$))
+            .subscribe(([prev, cur]) => {
+            let direction;
+            const option = typeof this.option === 'number'
+                ? {
+                    topDistance: this.option,
+                    bottomDistance: this.option,
+                }
+                : this.option || {};
+            if (cur > prev &&
+                viewEl.scrollTop >
+                    viewEl.scrollHeight -
+                        viewEl.clientHeight -
+                        (option.bottomDistance || defaultDistance)) {
+                direction = 'bottom';
+            }
+            else if (cur < prev &&
+                viewEl.scrollTop < (option.topDistance || defaultDistance)) {
+                direction = 'top';
+            }
+            this.scrollBorder.emit(direction);
+            direction === 'bottom' && this.scrollBottomBorder.emit();
+        });
+    }
+    static { this.ɵfac = function ScrollBorderObserverDirective_Factory(t) { return new (t || ScrollBorderObserverDirective)(i0.ɵɵdirectiveInject(i0.Injector)); }; }
+    static { this.ɵdir = /*@__PURE__*/ i0.ɵɵdefineDirective({ type: ScrollBorderObserverDirective, selectors: [["", "aclScrollBorderObserver", ""]], inputs: { option: ["aclScrollBorderObserver", "option"] }, outputs: { scrollBorder: "scrollBorder", scrollBottomBorder: "scrollBottomBorder" }, standalone: true }); }
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(ScrollBorderObserverDirective, [{
+        type: Directive,
+        args: [{
+                selector: '[aclScrollBorderObserver]',
+                standalone: true,
+            }]
+    }], function () { return [{ type: i0.Injector }]; }, { option: [{
+            type: Input,
+            args: ['aclScrollBorderObserver']
+        }], scrollBorder: [{
+            type: Output
+        }], scrollBottomBorder: [{
+            type: Output
+        }] }); })();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/core/directives/scroll-to-first-invalid.directive.mjs

@@ -0,0 +1,130 @@
+import { CdkScrollable } from '@angular/cdk/scrolling';
+import { Directive, ElementRef, HostBinding, HostListener, Input, Optional, } from '@angular/core';
+import { ControlContainer } from '@angular/forms';
+import { fromEvent, debounceTime, startWith, take } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/forms";
+import * as i2 from "@angular/cdk/scrolling";
+const FOCUSABLE_TAG_NAMES = ['INPUT', 'TEXTAREA'];
+const NG_INVALID = '.ng-invalid';
+const MARKED_CLASS_NAME = 'acl-scroll-to-first-invalid-marker';
+const SELECTORS = [
+    [
+        FOCUSABLE_TAG_NAMES.map(tagName => `${tagName}${NG_INVALID}`),
+        ...[
+            'aui-number-input',
+            'aui-tags-input',
+            'aui-select',
+            'aui-multi-select',
+            'aui-switch',
+            'aui-tree-select',
+        ].map(tagName => `${tagName}${NG_INVALID} input`),
+        `aui-radio-group${NG_INVALID}`,
+        `.${MARKED_CLASS_NAME}${NG_INVALID}`,
+    ].join(','),
+    NG_INVALID,
+];
+export class ScrollToFirstInvalidMarkerDirective {
+    constructor() {
+        this.aclScrollToFirstInvalidMarker = false;
+    }
+    static { this.ɵfac = function ScrollToFirstInvalidMarkerDirective_Factory(t) { return new (t || ScrollToFirstInvalidMarkerDirective)(); }; }
+    static { this.ɵdir = /*@__PURE__*/ i0.ɵɵdefineDirective({ type: ScrollToFirstInvalidMarkerDirective, selectors: [["", "aclScrollToFirstInvalidMarker", ""]], hostVars: 4, hostBindings: function ScrollToFirstInvalidMarkerDirective_HostBindings(rf, ctx) { if (rf & 2) {
+            i0.ɵɵclassProp("acl-scroll-to-first-invalid-marker", ctx.aclScrollToFirstInvalidMarker)("ng-invalid", ctx.aclScrollToFirstInvalidMarker);
+        } }, inputs: { aclScrollToFirstInvalidMarker: "aclScrollToFirstInvalidMarker" } }); }
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(ScrollToFirstInvalidMarkerDirective, [{
+        type: Directive,
+        args: [{
+                selector: '[aclScrollToFirstInvalidMarker]',
+            }]
+    }], null, { aclScrollToFirstInvalidMarker: [{
+            type: HostBinding,
+            args: [`class.${MARKED_CLASS_NAME}`]
+        }, {
+            type: HostBinding,
+            args: ['class.ng-invalid']
+        }, {
+            type: Input
+        }] }); })();
+export class ScrollToFirstInvalidDirective {
+    get containerEl() {
+        return this.cdkScrollable?.getElementRef().nativeElement || window;
+    }
+    onSubmit() {
+        requestAnimationFrame(() => {
+            if (this.aclScrollToFirstInvalid === ''
+                ? this.controlContainer.invalid
+                : this.aclScrollToFirstInvalid) {
+                this.scrollToFirstInvalid();
+            }
+        });
+    }
+    constructor(elRef, controlContainer, cdkScrollable) {
+        this.elRef = elRef;
+        this.controlContainer = controlContainer;
+        this.cdkScrollable = cdkScrollable;
+        this.labelOffset = this.cdkScrollable ? 20 : 150;
+    }
+    scrollToFirstInvalid() {
+        const firstInvalidEl = this.getFirstInvalidInput();
+        if (!firstInvalidEl) {
+            return;
+        }
+        this.containerEl.scrollTo({
+            top: this.getTopOffset(firstInvalidEl),
+            behavior: 'smooth',
+        });
+        if (FOCUSABLE_TAG_NAMES.includes(firstInvalidEl.tagName)) {
+            fromEvent(this.containerEl, 'scroll')
+                .pipe(startWith(null), debounceTime(100), take(1))
+                .subscribe(() => firstInvalidEl.focus());
+        }
+    }
+    getFirstInvalidInput() {
+        const el = this.elRef.nativeElement;
+        const hiddenEls = Array.from(el.querySelectorAll('[hidden]'));
+        for (const selector of SELECTORS) {
+            const ctrlEls = Array.from(el.querySelectorAll(selector));
+            for (const ctrlEl of ctrlEls) {
+                if (hiddenEls.some(hiddenEl => hiddenEl === ctrlEl || hiddenEl.contains(ctrlEl))) {
+                    continue;
+                }
+                return ctrlEl;
+            }
+        }
+    }
+    getTopOffset(controlEl) {
+        const labelOffset = this.labelOffset;
+        const controlElTop = controlEl.getBoundingClientRect().top;
+        if (this.cdkScrollable) {
+            const containerEl = this.containerEl;
+            const containerTop = containerEl.getBoundingClientRect().top;
+            const absoluteControlElTop = controlElTop + containerEl.scrollTop;
+            return absoluteControlElTop - containerTop - labelOffset;
+        }
+        const absoluteControlElTop = controlElTop + window.scrollY;
+        return absoluteControlElTop - labelOffset;
+    }
+    static { this.ɵfac = function ScrollToFirstInvalidDirective_Factory(t) { return new (t || ScrollToFirstInvalidDirective)(i0.ɵɵdirectiveInject(i0.ElementRef), i0.ɵɵdirectiveInject(i1.ControlContainer), i0.ɵɵdirectiveInject(i2.CdkScrollable, 8)); }; }
+    static { this.ɵdir = /*@__PURE__*/ i0.ɵɵdefineDirective({ type: ScrollToFirstInvalidDirective, selectors: [["", "aclScrollToFirstInvalid", ""]], hostBindings: function ScrollToFirstInvalidDirective_HostBindings(rf, ctx) { if (rf & 1) {
+            i0.ɵɵlistener("ngSubmit", function ScrollToFirstInvalidDirective_ngSubmit_HostBindingHandler() { return ctx.onSubmit(); });
+        } }, inputs: { labelOffset: "labelOffset", aclScrollToFirstInvalid: "aclScrollToFirstInvalid" }, standalone: true }); }
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(ScrollToFirstInvalidDirective, [{
+        type: Directive,
+        args: [{
+                selector: '[aclScrollToFirstInvalid]',
+                standalone: true,
+            }]
+    }], function () { return [{ type: i0.ElementRef }, { type: i1.ControlContainer }, { type: i2.CdkScrollable, decorators: [{
+                type: Optional
+            }] }]; }, { labelOffset: [{
+            type: Input
+        }], aclScrollToFirstInvalid: [{
+            type: Input
+        }], onSubmit: [{
+            type: HostListener,
+            args: ['ngSubmit']
+        }] }); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"scroll-to-first-invalid.directive.js","sourceRoot":"","sources":["../../../../../../libs/common/src/core/directives/scroll-to-first-invalid.directive.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AACvD,OAAO,EACL,SAAS,EACT,UAAU,EACV,WAAW,EACX,YAAY,EACZ,KAAK,EACL,QAAQ,GACT,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAClD,OAAO,EAAE,SAAS,EAAE,YAAY,EAAE,SAAS,EAAE,IAAI,EAAE,MAAM,MAAM,CAAC;;;;AAEhE,MAAM,mBAAmB,GAAG,CAAC,OAAO,EAAE,UAAU,CAAC,CAAC;AAClD,MAAM,UAAU,GAAG,aAAa,CAAC;AACjC,MAAM,iBAAiB,GAAG,oCAAoC,CAAC;AAE/D,MAAM,SAAS,GAAG;IAChB;QACE,mBAAmB,CAAC,GAAG,CAAC,OAAO,CAAC,EAAE,CAAC,GAAG,OAAO,GAAG,UAAU,EAAE,CAAC;QAC7D,GAAG;YACD,kBAAkB;YAClB,gBAAgB;YAChB,YAAY;YACZ,kBAAkB;YAClB,YAAY;YACZ,iBAAiB;SAClB,CAAC,GAAG,CAAC,OAAO,CAAC,EAAE,CAAC,GAAG,OAAO,GAAG,UAAU,QAAQ,CAAC;QACjD,kBAAkB,UAAU,EAAE;QAC9B,IAAI,iBAAiB,GAAG,UAAU,EAAE;KACrC,CAAC,IAAI,CAAC,GAAG,CAAC;IACX,UAAU;CACX,CAAC;AAKF,MAAM,OAAO,mCAAmC;IAHhD;QAOE,kCAA6B,GAAG,KAAK,CAAC;KACvC;oGALY,mCAAmC;oEAAnC,mCAAmC;;;;uFAAnC,mCAAmC;cAH/C,SAAS;eAAC;gBACT,QAAQ,EAAE,iCAAiC;aAC5C;gBAKC,6BAA6B;kBAH5B,WAAW;mBAAC,SAAS,iBAAiB,EAAE;;kBACxC,WAAW;mBAAC,kBAAkB;;kBAC9B,KAAK;;AAQR,MAAM,OAAO,6BAA6B;IAOxC,IAAI,WAAW;QACb,OAAO,IAAI,CAAC,aAAa,EAAE,aAAa,EAAE,CAAC,aAAa,IAAI,MAAM,CAAC;IACrE,CAAC;IAGD,QAAQ;QACN,qBAAqB,CAAC,GAAG,EAAE;YACzB,IACE,IAAI,CAAC,uBAAuB,KAAK,EAAE;gBACjC,CAAC,CAAC,IAAI,CAAC,gBAAgB,CAAC,OAAO;gBAC/B,CAAC,CAAC,IAAI,CAAC,uBAAuB,EAChC;gBACA,IAAI,CAAC,oBAAoB,EAAE,CAAC;aAC7B;QACH,CAAC,CAAC,CAAC;IACL,CAAC;IAED,YACmB,KAA8B,EAC9B,gBAAkC,EACtB,aAA4B;QAFxC,UAAK,GAAL,KAAK,CAAyB;QAC9B,qBAAgB,GAAhB,gBAAgB,CAAkB;QACtB,kBAAa,GAAb,aAAa,CAAe;QAzB3D,gBAAW,GAAG,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC;IA0BzC,CAAC;IAEJ,oBAAoB;QAClB,MAAM,cAAc,GAAG,IAAI,CAAC,oBAAoB,EAAE,CAAC;QAEnD,IAAI,CAAC,cAAc,EAAE;YACnB,OAAO;SACR;QAED,IAAI,CAAC,WAAW,CAAC,QAAQ,CAAC;YACxB,GAAG,EAAE,IAAI,CAAC,YAAY,CAAC,cAAc,CAAC;YACtC,QAAQ,EAAE,QAAQ;SACnB,CAAC,CAAC;QAEH,IAAI,mBAAmB,CAAC,QAAQ,CAAC,cAAc,CAAC,OAAO,CAAC,EAAE;YACxD,SAAS,CAAC,IAAI,CAAC,WAAW,EAAE,QAAQ,CAAC;iBAClC,IAAI,CAAC,SAAS,CAAC,IAAY,CAAC,EAAE,YAAY,CAAC,GAAG,CAAC,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC;iBACzD,SAAS,CAAC,GAAG,EAAE,CAAC,cAAc,CAAC,KAAK,EAAE,CAAC,CAAC;SAC5C;IACH,CAAC;IAED,oBAAoB;QAClB,MAAM,EAAE,GAAG,IAAI,CAAC,KAAK,CAAC,aAAa,CAAC;QACpC,MAAM,SAAS,GAAG,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC,gBAAgB,CAAC,UAAU,CAAC,CAAC,CAAC;QAC9D,KAAK,MAAM,QAAQ,IAAI,SAAS,EAAE;YAChC,MAAM,OAAO,GAAG,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC,gBAAgB,CAAc,QAAQ,CAAC,CAAC,CAAC;YACvE,KAAK,MAAM,MAAM,IAAI,OAAO,EAAE;gBAC5B,IACE,SAAS,CAAC,IAAI,CACZ,QAAQ,CAAC,EAAE,CAAC,QAAQ,KAAK,MAAM,IAAI,QAAQ,CAAC,QAAQ,CAAC,MAAM,CAAC,CAC7D,EACD;oBACA,SAAS;iBACV;gBACD,OAAO,MAAM,CAAC;aACf;SACF;IACH,CAAC;IAEO,YAAY,CAAC,SAAsB;QACzC,MAAM,WAAW,GAAG,IAAI,CAAC,WAAW,CAAC;QACrC,MAAM,YAAY,GAAG,SAAS,CAAC,qBAAqB,EAAE,CAAC,GAAG,CAAC;QAE3D,IAAI,IAAI,CAAC,aAAa,EAAE;YACtB,MAAM,WAAW,GAAG,IAAI,CAAC,WAA0B,CAAC;YACpD,MAAM,YAAY,GAAG,WAAW,CAAC,qBAAqB,EAAE,CAAC,GAAG,CAAC;YAC7D,MAAM,oBAAoB,GAAG,YAAY,GAAG,WAAW,CAAC,SAAS,CAAC;YAClE,OAAO,oBAAoB,GAAG,YAAY,GAAG,WAAW,CAAC;SAC1D;QAED,MAAM,oBAAoB,GAAG,YAAY,GAAG,MAAM,CAAC,OAAO,CAAC;QAC3D,OAAO,oBAAoB,GAAG,WAAW,CAAC;IAC5C,CAAC;8FAhFU,6BAA6B;oEAA7B,6BAA6B;oHAA7B,cAAU;;;uFAAV,6BAA6B;cAJzC,SAAS;eAAC;gBACT,QAAQ,EAAE,2BAA2B;gBACrC,UAAU,EAAE,IAAI;aACjB;;sBA4BI,QAAQ;wBAzBX,WAAW;kBADV,KAAK;YAIN,uBAAuB;kBADtB,KAAK;YAQN,QAAQ;kBADP,YAAY;mBAAC,UAAU","sourcesContent":["import { CdkScrollable } from '@angular/cdk/scrolling';\nimport {\n  Directive,\n  ElementRef,\n  HostBinding,\n  HostListener,\n  Input,\n  Optional,\n} from '@angular/core';\nimport { ControlContainer } from '@angular/forms';\nimport { fromEvent, debounceTime, startWith, take } from 'rxjs';\n\nconst FOCUSABLE_TAG_NAMES = ['INPUT', 'TEXTAREA'];\nconst NG_INVALID = '.ng-invalid';\nconst MARKED_CLASS_NAME = 'acl-scroll-to-first-invalid-marker';\n\nconst SELECTORS = [\n  [\n    FOCUSABLE_TAG_NAMES.map(tagName => `${tagName}${NG_INVALID}`),\n    ...[\n      'aui-number-input',\n      'aui-tags-input',\n      'aui-select',\n      'aui-multi-select',\n      'aui-switch',\n      'aui-tree-select',\n    ].map(tagName => `${tagName}${NG_INVALID} input`),\n    `aui-radio-group${NG_INVALID}`,\n    `.${MARKED_CLASS_NAME}${NG_INVALID}`,\n  ].join(','),\n  NG_INVALID,\n];\n\n@Directive({\n  selector: '[aclScrollToFirstInvalidMarker]',\n})\nexport class ScrollToFirstInvalidMarkerDirective {\n  @HostBinding(`class.${MARKED_CLASS_NAME}`)\n  @HostBinding('class.ng-invalid')\n  @Input()\n  aclScrollToFirstInvalidMarker = false;\n}\n\n@Directive({\n  selector: '[aclScrollToFirstInvalid]',\n  standalone: true,\n})\nexport class ScrollToFirstInvalidDirective {\n  @Input()\n  labelOffset = this.cdkScrollable ? 20 : 150;\n\n  @Input()\n  aclScrollToFirstInvalid: boolean | '';\n\n  get containerEl() {\n    return this.cdkScrollable?.getElementRef().nativeElement || window;\n  }\n\n  @HostListener('ngSubmit')\n  onSubmit() {\n    requestAnimationFrame(() => {\n      if (\n        this.aclScrollToFirstInvalid === ''\n          ? this.controlContainer.invalid\n          : this.aclScrollToFirstInvalid\n      ) {\n        this.scrollToFirstInvalid();\n      }\n    });\n  }\n\n  constructor(\n    private readonly elRef: ElementRef<HTMLElement>,\n    private readonly controlContainer: ControlContainer,\n    @Optional() private readonly cdkScrollable: CdkScrollable,\n  ) {}\n\n  scrollToFirstInvalid() {\n    const firstInvalidEl = this.getFirstInvalidInput();\n\n    if (!firstInvalidEl) {\n      return;\n    }\n\n    this.containerEl.scrollTo({\n      top: this.getTopOffset(firstInvalidEl),\n      behavior: 'smooth',\n    });\n\n    if (FOCUSABLE_TAG_NAMES.includes(firstInvalidEl.tagName)) {\n      fromEvent(this.containerEl, 'scroll')\n        .pipe(startWith(null as void), debounceTime(100), take(1))\n        .subscribe(() => firstInvalidEl.focus());\n    }\n  }\n\n  getFirstInvalidInput() {\n    const el = this.elRef.nativeElement;\n    const hiddenEls = Array.from(el.querySelectorAll('[hidden]'));\n    for (const selector of SELECTORS) {\n      const ctrlEls = Array.from(el.querySelectorAll<HTMLElement>(selector));\n      for (const ctrlEl of ctrlEls) {\n        if (\n          hiddenEls.some(\n            hiddenEl => hiddenEl === ctrlEl || hiddenEl.contains(ctrlEl),\n          )\n        ) {\n          continue;\n        }\n        return ctrlEl;\n      }\n    }\n  }\n\n  private getTopOffset(controlEl: HTMLElement): number {\n    const labelOffset = this.labelOffset;\n    const controlElTop = controlEl.getBoundingClientRect().top;\n\n    if (this.cdkScrollable) {\n      const containerEl = this.containerEl as HTMLElement;\n      const containerTop = containerEl.getBoundingClientRect().top;\n      const absoluteControlElTop = controlElTop + containerEl.scrollTop;\n      return absoluteControlElTop - containerTop - labelOffset;\n    }\n\n    const absoluteControlElTop = controlElTop + window.scrollY;\n    return absoluteControlElTop - labelOffset;\n  }\n}\n"]}