@alauda-fe/common 1.0.0-next.0

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":"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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/core/guards/feature.guard.mjs

@@ -0,0 +1,60 @@
+import { Inject, Injectable, InjectionToken, Optional } from '@angular/core';
+import { map } from 'rxjs';
+import { FeatureGateService } from '../services/feature-gate.service';
+import { SilentlyNavigateService } from '../services/silently-navigate.service';
+import * as i0 from "@angular/core";
+import * as i1 from "../services/feature-gate.service";
+import * as i2 from "../services/silently-navigate.service";
+export const DEFAULT_FEATURE_FORBIDDEN_URL = 'feature-forbidden';
+export const GET_CURRENT_CLUSTER = new InjectionToken('Get current cluster function');
+/**
+ * ```ts
+ * data: {
+ *  path: 'home',
+ *  canActivate: [ FeatureGuard ],
+ *  data: { featureName: 'ace3', guard_url: 'xxx', logTitle: 'devops'  }
+ * }
+ * ```
+ */
+export class FeatureGuard {
+    constructor(featureGate, silentlyNavigate, getCluster) {
+        this.featureGate = featureGate;
+        this.silentlyNavigate = silentlyNavigate;
+        this.getCluster = getCluster;
+    }
+    canActivateChild(childRoute, state) {
+        return this.canActivate(childRoute, state);
+    }
+    canActivate(route, state) {
+        const data = {
+            featureName: '',
+            guard_url: DEFAULT_FEATURE_FORBIDDEN_URL,
+            logTitle: '',
+            ...route.data,
+        };
+        let currentCluster;
+        if (this.getCluster) {
+            currentCluster = this.getCluster(route);
+        }
+        return this.featureGate.isEnabled(data.featureName, currentCluster).pipe(map(enabled => {
+            if (enabled)
+                return true;
+            const logTitle = data.logTitle ? `/${data.logTitle}` : '';
+            const errorUrl = `${data.guard_url}/${data.featureName}${logTitle}`;
+            this.silentlyNavigate.navigate(state.url, errorUrl);
+            return false;
+        }));
+    }
+    static { this.ɵfac = function FeatureGuard_Factory(t) { return new (t || FeatureGuard)(i0.ɵɵinject(i1.FeatureGateService), i0.ɵɵinject(i2.SilentlyNavigateService), i0.ɵɵinject(GET_CURRENT_CLUSTER, 8)); }; }
+    static { this.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: FeatureGuard, factory: FeatureGuard.ɵfac, providedIn: 'root' }); }
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(FeatureGuard, [{
+        type: Injectable,
+        args: [{ providedIn: 'root' }]
+    }], function () { return [{ type: i1.FeatureGateService }, { type: i2.SilentlyNavigateService }, { type: undefined, decorators: [{
+                type: Inject,
+                args: [GET_CURRENT_CLUSTER]
+            }, {
+                type: Optional
+            }] }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/core/guards/index.mjs

@@ -0,0 +1,5 @@
+export * from './feature.guard';
+export * from './intercept-deactivate.guard';
+export * from './project-namespace.guard';
+export * from './leave-edit-page.guard';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9saWJzL2NvbW1vbi9zcmMvY29yZS9ndWFyZHMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxpQkFBaUIsQ0FBQztBQUNoQyxjQUFjLDhCQUE4QixDQUFDO0FBQzdDLGNBQWMsMkJBQTJCLENBQUM7QUFDMUMsY0FBYyx5QkFBeUIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vZmVhdHVyZS5ndWFyZCc7XG5leHBvcnQgKiBmcm9tICcuL2ludGVyY2VwdC1kZWFjdGl2YXRlLmd1YXJkJztcbmV4cG9ydCAqIGZyb20gJy4vcHJvamVjdC1uYW1lc3BhY2UuZ3VhcmQnO1xuZXhwb3J0ICogZnJvbSAnLi9sZWF2ZS1lZGl0LXBhZ2UuZ3VhcmQnO1xuIl19

package/esm2022/core/guards/intercept-deactivate.guard.mjs

@@ -0,0 +1,40 @@
+import { Injectable, Injector } from '@angular/core';
+import { from, Observable, of, switchMap } from 'rxjs';
+import { InterceptDeactivateService } from '../services/intercept-deactivate.service';
+import * as i0 from "@angular/core";
+export const ESCAPE_DEACTIVATE_GUARD = '__ESCAPE_DEACTIVATE_GUARD__';
+export const CURR_ESCAPE_DEACTIVATE_GUARD = '__CURR_ESCAPE_DEACTIVATE_GUARD__';
+export class InterceptDeactivateGuard {
+    constructor(injector) {
+        this.injector = injector;
+    }
+    canDeactivate(component, currentRoute, currentState, nextState) {
+        let { canDeactivate } = component;
+        if (typeof canDeactivate === 'function') {
+            canDeactivate = canDeactivate();
+        }
+        const result$ = canDeactivate instanceof Observable || canDeactivate instanceof Promise
+            ? from(canDeactivate)
+            : of(!!canDeactivate);
+        return result$.pipe(switchMap(canDeactivate => {
+            if (canDeactivate ||
+                CURR_ESCAPE_DEACTIVATE_GUARD === currentState.root.fragment ||
+                ESCAPE_DEACTIVATE_GUARD === nextState.root.fragment) {
+                return of(true);
+            }
+            return this.injector.get(InterceptDeactivateService).intercept({
+                title: currentRoute.data.interceptDeactivateTitle,
+                content: currentRoute.data.interceptDeactivateContent,
+                context: component,
+                errorFallback: false,
+            });
+        }));
+    }
+    static { this.ɵfac = function InterceptDeactivateGuard_Factory(t) { return new (t || InterceptDeactivateGuard)(i0.ɵɵinject(i0.Injector)); }; }
+    static { this.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: InterceptDeactivateGuard, factory: InterceptDeactivateGuard.ɵfac, providedIn: 'root' }); }
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(InterceptDeactivateGuard, [{
+        type: Injectable,
+        args: [{ providedIn: 'root' }]
+    }], function () { return [{ type: i0.Injector }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW50ZXJjZXB0LWRlYWN0aXZhdGUuZ3VhcmQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9saWJzL2NvbW1vbi9zcmMvY29yZS9ndWFyZHMvaW50ZXJjZXB0LWRlYWN0aXZhdGUuZ3VhcmQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFVBQVUsRUFBRSxRQUFRLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFNckQsT0FBTyxFQUFFLElBQUksRUFBRSxVQUFVLEVBQUUsRUFBRSxFQUFFLFNBQVMsRUFBRSxNQUFNLE1BQU0sQ0FBQztBQUV2RCxPQUFPLEVBQUUsMEJBQTBCLEVBQUUsTUFBTSwwQ0FBMEMsQ0FBQzs7QUFFdEYsTUFBTSxDQUFDLE1BQU0sdUJBQXVCLEdBQUcsNkJBQTZCLENBQUM7QUFDckUsTUFBTSxDQUFDLE1BQU0sNEJBQTRCLEdBQUcsa0NBQWtDLENBQUM7QUFHL0UsTUFBTSxPQUFPLHdCQUF3QjtJQUNuQyxZQUE2QixRQUFrQjtRQUFsQixhQUFRLEdBQVIsUUFBUSxDQUFVO0lBQUcsQ0FBQztJQUVuRCxhQUFhLENBQ1gsU0FBaUIsRUFDakIsWUFBb0MsRUFDcEMsWUFBaUMsRUFDakMsU0FBOEI7UUFFOUIsSUFBSSxFQUFFLGFBQWEsRUFBRSxHQUFHLFNBQXdDLENBQUM7UUFFakUsSUFBSSxPQUFPLGFBQWEsS0FBSyxVQUFVLEVBQUU7WUFDdkMsYUFBYSxHQUFHLGFBQWEsRUFBRSxDQUFDO1NBQ2pDO1FBRUQsTUFBTSxPQUFPLEdBQ1gsYUFBYSxZQUFZLFVBQVUsSUFBSSxhQUFhLFlBQVksT0FBTztZQUNyRSxDQUFDLENBQUMsSUFBSSxDQUFDLGFBQWEsQ0FBQztZQUNyQixDQUFDLENBQUMsRUFBRSxDQUFDLENBQUMsQ0FBQyxhQUFhLENBQUMsQ0FBQztRQUUxQixPQUFPLE9BQU8sQ0FBQyxJQUFJLENBQ2pCLFNBQVMsQ0FBQyxhQUFhLENBQUMsRUFBRTtZQUN4QixJQUNFLGFBQWE7Z0JBQ2IsNEJBQTRCLEtBQUssWUFBWSxDQUFDLElBQUksQ0FBQyxRQUFRO2dCQUMzRCx1QkFBdUIsS0FBSyxTQUFTLENBQUMsSUFBSSxDQUFDLFFBQVEsRUFDbkQ7Z0JBQ0EsT0FBTyxFQUFFLENBQUMsSUFBSSxDQUFDLENBQUM7YUFDakI7WUFFRCxPQUFPLElBQUksQ0FBQyxRQUFRLENBQUMsR0FBRyxDQUFDLDBCQUEwQixDQUFDLENBQUMsU0FBUyxDQUFDO2dCQUM3RCxLQUFLLEVBQUUsWUFBWSxDQUFDLElBQUksQ0FBQyx3QkFBd0I7Z0JBQ2pELE9BQU8sRUFBRSxZQUFZLENBQUMsSUFBSSxDQUFDLDBCQUEwQjtnQkFDckQsT0FBTyxFQUFFLFNBQVM7Z0JBQ2xCLGFBQWEsRUFBRSxLQUFLO2FBQ3JCLENBQUMsQ0FBQztRQUNMLENBQUMsQ0FBQyxDQUNILENBQUM7SUFDSixDQUFDO3lGQXRDVSx3QkFBd0I7dUVBQXhCLHdCQUF3QixXQUF4Qix3QkFBd0IsbUJBRFgsTUFBTTs7dUZBQ25CLHdCQUF3QjtjQURwQyxVQUFVO2VBQUMsRUFBRSxVQUFVLEVBQUUsTUFBTSxFQUFFIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW5qZWN0YWJsZSwgSW5qZWN0b3IgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7XG4gIEFjdGl2YXRlZFJvdXRlU25hcHNob3QsXG4gIENhbkRlYWN0aXZhdGUsXG4gIFJvdXRlclN0YXRlU25hcHNob3QsXG59IGZyb20gJ0Bhbmd1bGFyL3JvdXRlcic7XG5pbXBvcnQgeyBmcm9tLCBPYnNlcnZhYmxlLCBvZiwgc3dpdGNoTWFwIH0gZnJvbSAncnhqcyc7XG5cbmltcG9ydCB7IEludGVyY2VwdERlYWN0aXZhdGVTZXJ2aWNlIH0gZnJvbSAnLi4vc2VydmljZXMvaW50ZXJjZXB0LWRlYWN0aXZhdGUuc2VydmljZSc7XG5cbmV4cG9ydCBjb25zdCBFU0NBUEVfREVBQ1RJVkFURV9HVUFSRCA9ICdfX0VTQ0FQRV9ERUFDVElWQVRFX0dVQVJEX18nO1xuZXhwb3J0IGNvbnN0IENVUlJfRVNDQVBFX0RFQUNUSVZBVEVfR1VBUkQgPSAnX19DVVJSX0VTQ0FQRV9ERUFDVElWQVRFX0dVQVJEX18nO1xuXG5ASW5qZWN0YWJsZSh7IHByb3ZpZGVkSW46ICdyb290JyB9KVxuZXhwb3J0IGNsYXNzIEludGVyY2VwdERlYWN0aXZhdGVHdWFyZCBpbXBsZW1lbnRzIENhbkRlYWN0aXZhdGU8dW5rbm93bj4ge1xuICBjb25zdHJ1Y3Rvcihwcml2YXRlIHJlYWRvbmx5IGluamVjdG9yOiBJbmplY3Rvcikge31cblxuICBjYW5EZWFjdGl2YXRlKFxuICAgIGNvbXBvbmVudDogb2JqZWN0LFxuICAgIGN1cnJlbnRSb3V0ZTogQWN0aXZhdGVkUm91dGVTbmFwc2hvdCxcbiAgICBjdXJyZW50U3RhdGU6IFJvdXRlclN0YXRlU25hcHNob3QsXG4gICAgbmV4dFN0YXRlOiBSb3V0ZXJTdGF0ZVNuYXBzaG90LFxuICApIHtcbiAgICBsZXQgeyBjYW5EZWFjdGl2YXRlIH0gPSBjb21wb25lbnQgYXMgeyBjYW5EZWFjdGl2YXRlPzogdW5rbm93biB9O1xuXG4gICAgaWYgKHR5cGVvZiBjYW5EZWFjdGl2YXRlID09PSAnZnVuY3Rpb24nKSB7XG4gICAgICBjYW5EZWFjdGl2YXRlID0gY2FuRGVhY3RpdmF0ZSgpO1xuICAgIH1cblxuICAgIGNvbnN0IHJlc3VsdCQgPVxuICAgICAgY2FuRGVhY3RpdmF0ZSBpbnN0YW5jZW9mIE9ic2VydmFibGUgfHwgY2FuRGVhY3RpdmF0ZSBpbnN0YW5jZW9mIFByb21pc2VcbiAgICAgICAgPyBmcm9tKGNhbkRlYWN0aXZhdGUpXG4gICAgICAgIDogb2YoISFjYW5EZWFjdGl2YXRlKTtcblxuICAgIHJldHVybiByZXN1bHQkLnBpcGUoXG4gICAgICBzd2l0Y2hNYXAoY2FuRGVhY3RpdmF0ZSA9PiB7XG4gICAgICAgIGlmIChcbiAgICAgICAgICBjYW5EZWFjdGl2YXRlIHx8XG4gICAgICAgICAgQ1VSUl9FU0NBUEVfREVBQ1RJVkFURV9HVUFSRCA9PT0gY3VycmVudFN0YXRlLnJvb3QuZnJhZ21lbnQgfHxcbiAgICAgICAgICBFU0NBUEVfREVBQ1RJVkFURV9HVUFSRCA9PT0gbmV4dFN0YXRlLnJvb3QuZnJhZ21lbnRcbiAgICAgICAgKSB7XG4gICAgICAgICAgcmV0dXJuIG9mKHRydWUpO1xuICAgICAgICB9XG5cbiAgICAgICAgcmV0dXJuIHRoaXMuaW5qZWN0b3IuZ2V0KEludGVyY2VwdERlYWN0aXZhdGVTZXJ2aWNlKS5pbnRlcmNlcHQoe1xuICAgICAgICAgIHRpdGxlOiBjdXJyZW50Um91dGUuZGF0YS5pbnRlcmNlcHREZWFjdGl2YXRlVGl0bGUsXG4gICAgICAgICAgY29udGVudDogY3VycmVudFJvdXRlLmRhdGEuaW50ZXJjZXB0RGVhY3RpdmF0ZUNvbnRlbnQsXG4gICAgICAgICAgY29udGV4dDogY29tcG9uZW50LFxuICAgICAgICAgIGVycm9yRmFsbGJhY2s6IGZhbHNlLFxuICAgICAgICB9KTtcbiAgICAgIH0pLFxuICAgICk7XG4gIH1cbn1cbiJdfQ==

package/esm2022/core/guards/leave-edit-page.guard.mjs

@@ -0,0 +1,32 @@
+import { DialogService } from '@alauda/ui';
+import { Injectable } from '@angular/core';
+import { from, of, map } from 'rxjs';
+import { TranslateService } from '../../translate/translate.service';
+import { ESCAPE_DEACTIVATE_CHECK } from '../constants';
+import { skipError } from '../utils';
+import * as i0 from "@angular/core";
+import * as i1 from "@alauda/ui";
+import * as i2 from "../../translate/translate.service";
+export class EditPageLeaveGuardService {
+    constructor(dialogService, translate) {
+        this.dialogService = dialogService;
+        this.translate = translate;
+    }
+    canDeactivate(_, _ars, _rss, nextState) {
+        if (nextState.root.fragment === ESCAPE_DEACTIVATE_CHECK) {
+            return of(true);
+        }
+        return from(this.dialogService.confirm({
+            title: this.translate.get('create_page_leave_tip'),
+            content: this.translate.get('create_page_leave_content'),
+            confirmText: this.translate.get('confirm'),
+            cancelText: this.translate.get('cancel'),
+        })).pipe(map(() => true), skipError(false));
+    }
+    static { this.ɵfac = function EditPageLeaveGuardService_Factory(t) { return new (t || EditPageLeaveGuardService)(i0.ɵɵinject(i1.DialogService), i0.ɵɵinject(i2.TranslateService)); }; }
+    static { this.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: EditPageLeaveGuardService, factory: EditPageLeaveGuardService.ɵfac }); }
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(EditPageLeaveGuardService, [{
+        type: Injectable
+    }], function () { return [{ type: i1.DialogService }, { type: i2.TranslateService }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,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