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

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

@@ -0,0 +1,145 @@
+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 { FieldNotAvailablePipe } from '../pipes/field-not-available.pipe';
+import { ObservableInput } from '../utils';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/forms";
+import * as i2 from "@alauda/ui";
+export class ReadonlyFieldDirective {
+    get isHidden() {
+        return this.hidden || this.aclReadonlyField;
+    }
+    constructor(control, 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 = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: ReadonlyFieldDirective, deps: [{ token: i1.NgControl }, { token: i0.ComponentFactoryResolver }, { token: i0.ViewContainerRef }, { token: i2.FormItemControlDirective, optional: true, self: true }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.1.1", type: ReadonlyFieldDirective, isStandalone: true, selector: "[aclReadonlyField]", inputs: { aclReadonlyField: "aclReadonlyField", hidden: "hidden", template: ["aclReadonlyFieldTemplate", "template"], context: ["aclReadonlyFieldTemplateContext", "context"] }, host: { properties: { "hidden": "this.isHidden" } }, ngImport: i0 }); }
+}
+__decorate([
+    ObservableInput(),
+    __metadata("design:type", Observable)
+], ReadonlyFieldDirective.prototype, "aclReadonlyField$", void 0);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: ReadonlyFieldDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[aclReadonlyField]',
+                    standalone: true,
+                }]
+        }], ctorParameters: () => [{ type: i1.NgControl }, { type: i0.ComponentFactoryResolver }, { type: i0.ViewContainerRef }, { type: i2.FormItemControlDirective, decorators: [{
+                    type: Self
+                }, {
+                    type: Optional
+                }] }], propDecorators: { 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 = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: SpanComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.1.1", type: SpanComponent, isStandalone: true, selector: "ng-component", ngImport: i0, template: `<span>{{ data | aclFieldNotAvailable }}</span>`, isInline: true, styles: ["span{word-break:break-all}\n"], dependencies: [{ kind: "pipe", type: FieldNotAvailablePipe, name: "aclFieldNotAvailable" }], changeDetection: i0.ChangeDetectionStrategy.Default }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: SpanComponent, decorators: [{
+            type: Component,
+            args: [{ template: `<span>{{ data | aclFieldNotAvailable }}</span>`, changeDetection: ChangeDetectionStrategy.Default, standalone: true, imports: [FieldNotAvailablePipe], styles: ["span{word-break:break-all}\n"] }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"readonly-field.directive.js","sourceRoot":"","sources":["../../../../../libs/dynamic-plugin-shared/src/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 { FieldNotAvailablePipe } from '../pipes/field-not-available.pipe';\nimport { ObservableInput } from '../utils';\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    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  standalone: true,\n  imports: [FieldNotAvailablePipe],\n})\nexport class SpanComponent<T = unknown> {\n  data: T;\n\n  setData(value: T) {\n    this.data = value;\n  }\n}\n"]}

package/esm2022/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 = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: ResizeDirective, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.1.1", type: ResizeDirective, isStandalone: true, selector: "[aclResize]", outputs: { resized: "resized" }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: ResizeDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[aclResize]',
+                    standalone: true,
+                }]
+        }], ctorParameters: () => [{ type: i0.ElementRef }], propDecorators: { resized: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/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 = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: ScrollBorderObserverDirective, deps: [{ token: i0.Injector }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.1.1", type: ScrollBorderObserverDirective, isStandalone: true, selector: "[aclScrollBorderObserver]", inputs: { option: ["aclScrollBorderObserver", "option"] }, outputs: { scrollBorder: "scrollBorder", scrollBottomBorder: "scrollBottomBorder" }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: ScrollBorderObserverDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[aclScrollBorderObserver]',
+                    standalone: true,
+                }]
+        }], ctorParameters: () => [{ type: i0.Injector }], propDecorators: { option: [{
+                type: Input,
+                args: ['aclScrollBorderObserver']
+            }], scrollBorder: [{
+                type: Output
+            }], scrollBottomBorder: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,126 @@
+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 = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: ScrollToFirstInvalidMarkerDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.1.1", type: ScrollToFirstInvalidMarkerDirective, selector: "[aclScrollToFirstInvalidMarker]", inputs: { aclScrollToFirstInvalidMarker: "aclScrollToFirstInvalidMarker" }, host: { properties: { "class.acl-scroll-to-first-invalid-marker": "this.aclScrollToFirstInvalidMarker", "class.ng-invalid": "this.aclScrollToFirstInvalidMarker" } }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: ScrollToFirstInvalidMarkerDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[aclScrollToFirstInvalidMarker]',
+                }]
+        }], propDecorators: { 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 = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: ScrollToFirstInvalidDirective, deps: [{ token: i0.ElementRef }, { token: i1.ControlContainer }, { token: i2.CdkScrollable, optional: true }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.1.1", type: ScrollToFirstInvalidDirective, isStandalone: true, selector: "[aclScrollToFirstInvalid]", inputs: { labelOffset: "labelOffset", aclScrollToFirstInvalid: "aclScrollToFirstInvalid" }, host: { listeners: { "ngSubmit": "onSubmit()" } }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: ScrollToFirstInvalidDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[aclScrollToFirstInvalid]',
+                    standalone: true,
+                }]
+        }], ctorParameters: () => [{ type: i0.ElementRef }, { type: i1.ControlContainer }, { type: i2.CdkScrollable, decorators: [{
+                    type: Optional
+                }] }], propDecorators: { 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/dynamic-plugin-shared/src/directives/scroll-to-first-invalid.directive.ts"],"names":[],"mappings":"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","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"]}

package/esm2022/directives/value-trace.directive.mjs

@@ -0,0 +1,61 @@
+import { __decorate, __metadata } from "tslib";
+import { Directive, Host, Inject, Input, } from '@angular/core';
+import { NgControl } from '@angular/forms';
+import { isFunction } from 'lodash-es';
+import { combineLatest, distinctUntilChanged, filter, Observable, startWith, Subject, takeUntil, tap, } from 'rxjs';
+import { ObservableInput } from '../utils';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/forms";
+/**
+ *
+ * Usage:
+ * If you want to trace value with control.
+ * The difference between aclValueTrack and ngModelChange is that aclValueTrack carries the first value.
+ * So it is not for changes, but for value traces
+ * For compatibility and cover the deprecation of ngModelChange, we provide aclValueTrackSkipFirst option
+ * eg:
+ * <input formControlName="name" [aclValueTrack]="function()">
+ *
+ */
+export class ControlValueTraceDirective {
+    ngOnDestroy() {
+        this.destroy$$.next();
+        this.destroy$$.complete();
+    }
+    ngOnInit() {
+        combineLatest([
+            this.ngControl.valueChanges.pipe(this.aclValueTrackSkipFirst ? tap() : startWith(this.ngControl.value)),
+            this.aclValueTrack$.pipe(distinctUntilChanged(), filter(i => isFunction(i))),
+        ])
+            .pipe(takeUntil(this.destroy$$))
+            .subscribe(([value, changeFn]) => changeFn(value));
+    }
+    constructor(ngControl) {
+        this.ngControl = ngControl;
+        this.aclValueTrackSkipFirst = false;
+        this.destroy$$ = new Subject();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: ControlValueTraceDirective, deps: [{ token: NgControl, host: true }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.1.1", type: ControlValueTraceDirective, isStandalone: true, selector: "[aclValueTrack]", inputs: { aclValueTrackSkipFirst: "aclValueTrackSkipFirst", aclValueTrack: "aclValueTrack" }, ngImport: i0 }); }
+}
+__decorate([
+    ObservableInput(),
+    __metadata("design:type", Observable)
+], ControlValueTraceDirective.prototype, "aclValueTrack$", void 0);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: ControlValueTraceDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[aclValueTrack]',
+                    standalone: true,
+                }]
+        }], ctorParameters: () => [{ type: i1.NgControl, decorators: [{
+                    type: Inject,
+                    args: [NgControl]
+                }, {
+                    type: Host
+                }] }], propDecorators: { aclValueTrackSkipFirst: [{
+                type: Input
+            }], aclValueTrack: [{
+                type: Input
+            }], aclValueTrack$: [] } });
+//# sourceMappingURL=data:application/json;base64,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