@alauda-fe/common 1.0.0-next.0

package/esm2022/core/constants/tokens.mjs

@@ -0,0 +1,129 @@
+/**
+ * @packageDocumentation
+ * @module utils
+ */
+import { InjectionToken, inject } from '@angular/core';
+import { retry } from 'rxjs';
+import { ajax } from 'rxjs/ajax';
+import { getBaseHref } from '../utils';
+export const idTokenKey = 'id_token';
+export const refreshTokenKey = 'refresh_token';
+export const codeKey = 'code';
+export const anonymousApis = [];
+export const modulesApi = '/console/api/v1/modules';
+export const tokenLoginApi = '/console/api/v1/token/login';
+export const tokenCallbackApi = '/console/api/v1/token/callback';
+export const tokenRefreshApi = '/console/api/v1/token/refresh';
+export const tokenInfoApi = '/console/api/v1/token/info';
+export const tokenNonAdminRedirectPath = '/';
+export const resourceDefinitions = {};
+const GLOBAL_ENVIRONMENTS = {
+    GLOBAL_NAMESPACE: 'cpaas-system',
+    LABEL_BASE_DOMAIN: 'cpaas.io',
+};
+let GLOBAL_ENVIRONMENTS_INITIALIZED = false;
+export function initGlobalEnvironments(env) {
+    if (GLOBAL_ENVIRONMENTS_INITIALIZED &&
+        // @ts-expect-error -- webpack specific
+        !module.hot) {
+        throw new Error('Global environments have been initialized');
+    }
+    GLOBAL_ENVIRONMENTS_INITIALIZED = true;
+    Object.assign(GLOBAL_ENVIRONMENTS, env);
+}
+export function fetchGlobalEnvironments(callback) {
+    ajax
+        .getJSON('api/v1/envs')
+        .pipe(retry(3))
+        .subscribe({
+        next: envs => {
+            initGlobalEnvironments(envs);
+            callback();
+        },
+        error: () => {
+            console.error('Failed to load environments.');
+        },
+    });
+}
+export function getGlobalEnvironments(name) {
+    if (!GLOBAL_ENVIRONMENTS_INITIALIZED) {
+        throw new Error('Global environments have not been initialized');
+    }
+    return name ? GLOBAL_ENVIRONMENTS[name] : GLOBAL_ENVIRONMENTS;
+}
+export const ANONYMOUS_APIS = new InjectionToken('anonymous apis no need for authorization', {
+    providedIn: 'root',
+    factory: () => anonymousApis,
+});
+export const ID_TOKEN_KEY = new InjectionToken('id_token param name for authorization', {
+    providedIn: 'root',
+    factory: () => idTokenKey,
+});
+export const REFRESH_TOKEN_KEY = new InjectionToken('refresh_token param name for authorization', {
+    providedIn: 'root',
+    factory: () => refreshTokenKey,
+});
+export const CODE_KEY = new InjectionToken('code param name fro authorization', {
+    providedIn: 'root',
+    factory: () => codeKey,
+});
+export const MODULES_API = new InjectionToken('api gateway configurations', {
+    providedIn: 'root',
+    factory: () => modulesApi,
+});
+export const TOKEN_LOGIN_API = new InjectionToken('api for get authorization configurations', {
+    providedIn: 'root',
+    factory: () => tokenLoginApi,
+});
+export const TOKEN_CALLBACK_API = new InjectionToken('api for resolve id_token from code', {
+    providedIn: 'root',
+    factory: () => tokenCallbackApi,
+});
+export const TOKEN_REFRESH_API = new InjectionToken('api for refresh id_token by refresh_token', {
+    providedIn: 'root',
+    factory: () => tokenRefreshApi,
+});
+export const TOKEN_INFO_API = new InjectionToken('api for validate id_token', {
+    providedIn: 'root',
+    factory: () => tokenInfoApi,
+});
+export const TOKEN_NON_ADMIN_REDIRECT_PATH = new InjectionToken('default redirect path for admin guard', {
+    providedIn: 'root',
+    factory: () => tokenNonAdminRedirectPath,
+});
+export const TOKEN_BASE_DOMAIN = new InjectionToken('default base domain string for annotations and labels of kubernetes resource', {
+    providedIn: 'root',
+    factory: () => getGlobalEnvironments('LABEL_BASE_DOMAIN'),
+});
+export const TOKEN_GLOBAL_NAMESPACE = new InjectionToken('default global namespace for namespaced global resource', {
+    providedIn: 'root',
+    factory: () => getGlobalEnvironments('GLOBAL_NAMESPACE'),
+});
+export const TOKEN_LOGO_URL = new InjectionToken('LOGO_URL', {
+    providedIn: 'root',
+    factory: () => getGlobalEnvironments('LOGO_URL'),
+});
+export const TOKEN_RESOURCE_DEFINITIONS = new InjectionToken('custom resource definitions', {
+    providedIn: 'root',
+    factory: () => resourceDefinitions,
+});
+export const TOKEN_BASE_HREF = new InjectionToken('base href from DOM', {
+    providedIn: 'root',
+    factory: getBaseHref,
+});
+export const TOKEN_DOCS_BASE_HREF = new InjectionToken('', {
+    providedIn: 'root',
+    factory: () => {
+        const baseHref = inject(TOKEN_BASE_HREF);
+        return baseHref === '/' ? '/' : baseHref.slice(0, -1) + '-docs/';
+    },
+});
+export const TOKEN_DISABLE_SESSION_MANAGE = new InjectionToken('disable session manage', {
+    providedIn: 'root',
+    factory: () => false,
+});
+export const TOKEN_CRYPTO_INTERCEPTOR_URL_REGEXPS = new InjectionToken('Configure the default encryption-enabled URL matching regular expression array', {
+    providedIn: 'root',
+    factory: () => [],
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tokens.js","sourceRoot":"","sources":["../../../../../../libs/common/src/core/constants/tokens.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @packageDocumentation\n * @module utils\n */\n\nimport { InjectionToken, inject } from '@angular/core';\nimport { retry } from 'rxjs';\nimport { ajax } from 'rxjs/ajax';\n\nimport { K8sResourceDefinitions } from '../../api/types';\nimport { Environments } from '../types/commons';\nimport { getBaseHref } from '../utils';\n\nexport const idTokenKey = 'id_token';\n\nexport const refreshTokenKey = 'refresh_token';\n\nexport const codeKey = 'code';\n\nexport const anonymousApis: Array<string | RegExp> = [];\n\nexport const modulesApi = '/console/api/v1/modules';\n\nexport const tokenLoginApi = '/console/api/v1/token/login';\n\nexport const tokenCallbackApi = '/console/api/v1/token/callback';\n\nexport const tokenRefreshApi = '/console/api/v1/token/refresh';\n\nexport const tokenInfoApi = '/console/api/v1/token/info';\n\nexport const tokenNonAdminRedirectPath = '/';\n\nexport const resourceDefinitions: K8sResourceDefinitions = {};\n\nconst GLOBAL_ENVIRONMENTS: Environments = {\n  GLOBAL_NAMESPACE: 'cpaas-system',\n  LABEL_BASE_DOMAIN: 'cpaas.io',\n};\n\nlet GLOBAL_ENVIRONMENTS_INITIALIZED = false;\n\nexport function initGlobalEnvironments(env: Environments): void {\n  if (\n    GLOBAL_ENVIRONMENTS_INITIALIZED &&\n    // @ts-expect-error -- webpack specific\n    !module.hot\n  ) {\n    throw new Error('Global environments have been initialized');\n  }\n\n  GLOBAL_ENVIRONMENTS_INITIALIZED = true;\n  Object.assign(GLOBAL_ENVIRONMENTS, env);\n}\n\nexport function fetchGlobalEnvironments(callback: () => void) {\n  ajax\n    .getJSON<Environments>('api/v1/envs')\n    .pipe(retry(3))\n    .subscribe({\n      next: envs => {\n        initGlobalEnvironments(envs);\n        callback();\n      },\n      error: () => {\n        console.error('Failed to load environments.');\n      },\n    });\n}\n\nexport function getGlobalEnvironments(): Readonly<Environments>;\nexport function getGlobalEnvironments<T extends keyof Environments>(\n  name: T,\n): Environments[T];\nexport function getGlobalEnvironments(name?: keyof Environments) {\n  if (!GLOBAL_ENVIRONMENTS_INITIALIZED) {\n    throw new Error('Global environments have not been initialized');\n  }\n\n  return name ? GLOBAL_ENVIRONMENTS[name] : GLOBAL_ENVIRONMENTS;\n}\n\nexport const ANONYMOUS_APIS = new InjectionToken(\n  'anonymous apis no need for authorization',\n  {\n    providedIn: 'root',\n    factory: () => anonymousApis,\n  },\n);\n\nexport const ID_TOKEN_KEY = new InjectionToken(\n  'id_token param name for authorization',\n  {\n    providedIn: 'root',\n    factory: () => idTokenKey,\n  },\n);\n\nexport const REFRESH_TOKEN_KEY = new InjectionToken(\n  'refresh_token param name for authorization',\n  {\n    providedIn: 'root',\n    factory: () => refreshTokenKey,\n  },\n);\n\nexport const CODE_KEY = new InjectionToken(\n  'code param name fro authorization',\n  {\n    providedIn: 'root',\n    factory: () => codeKey,\n  },\n);\n\nexport const MODULES_API = new InjectionToken('api gateway configurations', {\n  providedIn: 'root',\n  factory: () => modulesApi,\n});\n\nexport const TOKEN_LOGIN_API = new InjectionToken(\n  'api for get authorization configurations',\n  {\n    providedIn: 'root',\n    factory: () => tokenLoginApi,\n  },\n);\n\nexport const TOKEN_CALLBACK_API = new InjectionToken(\n  'api for resolve id_token from code',\n  {\n    providedIn: 'root',\n    factory: () => tokenCallbackApi,\n  },\n);\n\nexport const TOKEN_REFRESH_API = new InjectionToken(\n  'api for refresh id_token by refresh_token',\n  {\n    providedIn: 'root',\n    factory: () => tokenRefreshApi,\n  },\n);\n\nexport const TOKEN_INFO_API = new InjectionToken('api for validate id_token', {\n  providedIn: 'root',\n  factory: () => tokenInfoApi,\n});\n\nexport const TOKEN_NON_ADMIN_REDIRECT_PATH = new InjectionToken(\n  'default redirect path for admin guard',\n  {\n    providedIn: 'root',\n    factory: () => tokenNonAdminRedirectPath,\n  },\n);\n\nexport const TOKEN_BASE_DOMAIN = new InjectionToken(\n  'default base domain string for annotations and labels of kubernetes resource',\n  {\n    providedIn: 'root',\n    factory: () => getGlobalEnvironments('LABEL_BASE_DOMAIN'),\n  },\n);\n\nexport const TOKEN_GLOBAL_NAMESPACE = new InjectionToken(\n  'default global namespace for namespaced global resource',\n  {\n    providedIn: 'root',\n    factory: () => getGlobalEnvironments('GLOBAL_NAMESPACE'),\n  },\n);\n\nexport const TOKEN_LOGO_URL = new InjectionToken('LOGO_URL', {\n  providedIn: 'root',\n  factory: () => getGlobalEnvironments('LOGO_URL'),\n});\n\nexport const TOKEN_RESOURCE_DEFINITIONS = new InjectionToken(\n  'custom resource definitions',\n  {\n    providedIn: 'root',\n    factory: () => resourceDefinitions,\n  },\n);\n\nexport const TOKEN_BASE_HREF = new InjectionToken<string>(\n  'base href from DOM',\n  {\n    providedIn: 'root',\n    factory: getBaseHref,\n  },\n);\n\nexport const TOKEN_DOCS_BASE_HREF = new InjectionToken<string>('', {\n  providedIn: 'root',\n  factory: () => {\n    const baseHref = inject(TOKEN_BASE_HREF);\n    return baseHref === '/' ? '/' : baseHref.slice(0, -1) + '-docs/';\n  },\n});\n\nexport const TOKEN_DISABLE_SESSION_MANAGE = new InjectionToken(\n  'disable session manage',\n  {\n    providedIn: 'root',\n    factory: () => false,\n  },\n);\n\nexport const TOKEN_CRYPTO_INTERCEPTOR_URL_REGEXPS = new InjectionToken(\n  'Configure the default encryption-enabled URL matching regular expression array',\n  {\n    providedIn: 'root',\n    factory: () => [],\n  },\n);\n"]}

package/esm2022/core/directives/click-outside.directive.mjs

@@ -0,0 +1,51 @@
+import { Directive, ElementRef, EventEmitter, HostListener, Input, isDevMode, Output, } from '@angular/core';
+import * as i0 from "@angular/core";
+export class ClickOutsideDirective {
+    onBodyClick(event) {
+        const targetEl = event.target;
+        if (!this.el.nativeElement.contains(targetEl)) {
+            if (this.className) {
+                // @ts-ignore
+                for (const contain of document.querySelectorAll(`.${this.className}`)) {
+                    if (contain.contains(targetEl)) {
+                        return;
+                    }
+                }
+            }
+            this.clickOutside.emit(event);
+        }
+    }
+    constructor(el) {
+        this.el = el;
+        this.clickOutside = new EventEmitter();
+    }
+    ngOnInit() {
+        if (isDevMode() &&
+            this.className &&
+            !this.className.startsWith('click-outside')) {
+            // 因为松耦合的设计，所以增加一个范式要求
+            console.error('aclClickOutside 必须是空或以 click-outside 开头');
+        }
+    }
+    static { this.ɵfac = function ClickOutsideDirective_Factory(t) { return new (t || ClickOutsideDirective)(i0.ɵɵdirectiveInject(i0.ElementRef)); }; }
+    static { this.ɵdir = /*@__PURE__*/ i0.ɵɵdefineDirective({ type: ClickOutsideDirective, selectors: [["", "aclClickOutside", ""]], hostBindings: function ClickOutsideDirective_HostBindings(rf, ctx) { if (rf & 1) {
+            i0.ɵɵlistener("click", function ClickOutsideDirective_click_HostBindingHandler($event) { return ctx.onBodyClick($event); }, false, i0.ɵɵresolveDocument);
+        } }, inputs: { className: ["aclClickOutside", "className"] }, outputs: { clickOutside: "clickOutside" }, exportAs: ["aclClickOutside"], standalone: true }); }
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(ClickOutsideDirective, [{
+        type: Directive,
+        args: [{
+                selector: '[aclClickOutside]',
+                exportAs: 'aclClickOutside',
+                standalone: true,
+            }]
+    }], function () { return [{ type: i0.ElementRef }]; }, { className: [{
+            type: Input,
+            args: ['aclClickOutside']
+        }], clickOutside: [{
+            type: Output
+        }], onBodyClick: [{
+            type: HostListener,
+            args: ['document:click', ['$event']]
+        }] }); })();
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,76 @@
+import { __decorate, __metadata } from "tslib";
+import { coerceAttrBoolean } from '@alauda/ui';
+import { Directive, Input, Optional, Self, } from '@angular/core';
+import { ControlContainer, NgControl } from '@angular/forms';
+import { Observable, Subject, takeUntil } from 'rxjs';
+import { ObservableInput } from '../utils/decorators';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/forms";
+/**
+ *
+ * Usage:
+ * If you want to disable a formControl.
+ *
+ * eg:
+ * <input formControlName="name" [aclDisabled]="true">
+ *
+ */
+export class DisabledDirective {
+    constructor(ctrlContainer, ngControl) {
+        this.ctrlContainer = ctrlContainer;
+        this.ngControl = ngControl;
+        this.destroy$$ = new Subject();
+    }
+    ngOnInit() {
+        this.aclDisabled$
+            .pipe(takeUntil(this.destroy$$))
+            .subscribe(disabled => this.checkStatus(disabled));
+    }
+    ngOnDestroy() {
+        this.destroy$$.next();
+        this.destroy$$.complete();
+        switch (this.destroyStrategy) {
+            case 'check': {
+                this.checkStatus(this.aclDisabled);
+                break;
+            }
+            case 'disable': {
+                this.checkStatus(true);
+                break;
+            }
+            case 'enable': {
+                this.checkStatus(false);
+                break;
+            }
+        }
+    }
+    checkStatus(disabled) {
+        (this.ngControl ?? this.ctrlContainer)?.control?.[coerceAttrBoolean(disabled) ? 'disable' : 'enable']();
+    }
+    static { this.ɵfac = function DisabledDirective_Factory(t) { return new (t || DisabledDirective)(i0.ɵɵdirectiveInject(i1.ControlContainer, 10), i0.ɵɵdirectiveInject(i1.NgControl, 10)); }; }
+    static { this.ɵdir = /*@__PURE__*/ i0.ɵɵdefineDirective({ type: DisabledDirective, selectors: [["", "aclDisabled", ""]], inputs: { aclDisabled: "aclDisabled", destroyStrategy: "destroyStrategy" }, standalone: true }); }
+}
+__decorate([
+    ObservableInput(),
+    __metadata("design:type", Observable)
+], DisabledDirective.prototype, "aclDisabled$", void 0);
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(DisabledDirective, [{
+        type: Directive,
+        args: [{
+                selector: '[aclDisabled]',
+                standalone: true,
+            }]
+    }], function () { return [{ type: i1.ControlContainer, decorators: [{
+                type: Self
+            }, {
+                type: Optional
+            }] }, { type: i1.NgControl, decorators: [{
+                type: Self
+            }, {
+                type: Optional
+            }] }]; }, { aclDisabled: [{
+            type: Input
+        }], aclDisabled$: [], destroyStrategy: [{
+            type: Input
+        }] }); })();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/core/directives/feature-gate.directive.mjs

@@ -0,0 +1,87 @@
+/**
+ * @packageDocumentation
+ * @module utils
+ */
+import { ChangeDetectorRef, Directive, Input, TemplateRef, ViewContainerRef, 
+// cspell: disable-next-line
+ɵstringify as stringify, } from '@angular/core';
+import { distinctUntilChanged } from 'rxjs';
+import { FeatureGateService } from '../services/feature-gate.service';
+import * as i0 from "@angular/core";
+import * as i1 from "../services/feature-gate.service";
+/**
+ * @example
+ * ```
+ * <ng-container *aclFeatureGate="gate-name"></ng-container>
+ * ```
+ */
+export class FeatureGateDirective {
+    set then(templateRef) {
+        assertTemplate('aclFeatureGateThen', templateRef);
+        this.thenTemplateRef = templateRef;
+    }
+    set else(templateRef) {
+        assertTemplate('aclVersionGateElse', templateRef);
+        this.elseTemplateRef = templateRef;
+    }
+    constructor(container, featureGate, crd, templateRef) {
+        this.container = container;
+        this.featureGate = featureGate;
+        this.crd = crd;
+        this.featureName = null;
+        this.cluster = null;
+        this.thenTemplateRef = null;
+        this.elseTemplateRef = null;
+        this.subscription = null;
+        this.thenTemplateRef = templateRef;
+    }
+    ngOnInit() {
+        if (!this.featureName) {
+            this.container.createEmbeddedView(this.thenTemplateRef);
+            return;
+        }
+        this.subscription = this.featureGate
+            .isEnabled(this.featureName, this.cluster)
+            .pipe(distinctUntilChanged())
+            .subscribe(enabled => {
+            this.container.clear();
+            if (enabled) {
+                this.container.createEmbeddedView(this.thenTemplateRef);
+            }
+            else if (this.elseTemplateRef) {
+                this.container.createEmbeddedView(this.elseTemplateRef);
+            }
+            this.crd.markForCheck();
+        });
+    }
+    ngOnDestroy() {
+        if (this.subscription) {
+            this.subscription.unsubscribe();
+        }
+    }
+    static { this.ɵfac = function FeatureGateDirective_Factory(t) { return new (t || FeatureGateDirective)(i0.ɵɵdirectiveInject(i0.ViewContainerRef), i0.ɵɵdirectiveInject(i1.FeatureGateService), i0.ɵɵdirectiveInject(i0.ChangeDetectorRef), i0.ɵɵdirectiveInject(i0.TemplateRef)); }; }
+    static { this.ɵdir = /*@__PURE__*/ i0.ɵɵdefineDirective({ type: FeatureGateDirective, selectors: [["", "aclFeatureGate", ""]], inputs: { featureName: ["aclFeatureGate", "featureName"], cluster: ["aclFeatureGateCluster", "cluster"], then: ["aclFeatureGateThen", "then"], else: ["aclFeatureGateElse", "else"] } }); }
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(FeatureGateDirective, [{
+        type: Directive,
+        args: [{ selector: '[aclFeatureGate]' }]
+    }], function () { return [{ type: i0.ViewContainerRef }, { type: i1.FeatureGateService }, { type: i0.ChangeDetectorRef }, { type: i0.TemplateRef }]; }, { featureName: [{
+            type: Input,
+            args: ['aclFeatureGate']
+        }], cluster: [{
+            type: Input,
+            args: ['aclFeatureGateCluster']
+        }], then: [{
+            type: Input,
+            args: ['aclFeatureGateThen']
+        }], else: [{
+            type: Input,
+            args: ['aclFeatureGateElse']
+        }] }); })();
+function assertTemplate(property, templateRef) {
+    const isTemplateRefOrNull = !!(!templateRef || templateRef.createEmbeddedView);
+    if (!isTemplateRefOrNull) {
+        throw new Error(`${property} must be a TemplateRef, but received '${stringify(templateRef)}'.`);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/core/directives/index.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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9saWJzL2NvbW1vbi9zcmMvY29yZS9kaXJlY3RpdmVzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsc0JBQXNCLENBQUM7QUFDckMsY0FBYywwQkFBMEIsQ0FBQztBQUN6QyxjQUFjLGtDQUFrQyxDQUFDO0FBQ2pELGNBQWMsNEJBQTRCLENBQUM7QUFDM0MsY0FBYyxpQ0FBaUMsQ0FBQztBQUNoRCxjQUFjLDRCQUE0QixDQUFDO0FBQzNDLGNBQWMsb0JBQW9CLENBQUM7QUFDbkMsY0FBYyxxQ0FBcUMsQ0FBQztBQUNwRCxjQUFjLG9DQUFvQyxDQUFDO0FBQ25ELGNBQWMsMkJBQTJCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2Rpc2FibGVkLmRpcmVjdGl2ZSc7XG5leHBvcnQgKiBmcm9tICcuL2ZlYXR1cmUtZ2F0ZS5kaXJlY3RpdmUnO1xuZXhwb3J0ICogZnJvbSAnLi9pbnRlcmNlcHQtZGVhY3RpdmF0ZS5kaXJlY3RpdmUnO1xuZXhwb3J0ICogZnJvbSAnLi9sYXN0LWZvcm0taXRlbS5kaXJlY3RpdmUnO1xuZXhwb3J0ICogZnJvbSAnLi9wYWdlLWhlYWRlci1jb250ZW50LmRpcmVjdGl2ZSc7XG5leHBvcnQgKiBmcm9tICcuL3JlYWRvbmx5LWZpZWxkLmRpcmVjdGl2ZSc7XG5leHBvcnQgKiBmcm9tICcuL3Jlc2l6ZS5kaXJlY3RpdmUnO1xuZXhwb3J0ICogZnJvbSAnLi9zY3JvbGwtdG8tZmlyc3QtaW52YWxpZC5kaXJlY3RpdmUnO1xuZXhwb3J0ICogZnJvbSAnLi9zY3JvbGwtYm9yZGVyLW9ic2VydmVyLmRpcmVjdGl2ZSc7XG5leHBvcnQgKiBmcm9tICcuL2NsaWNrLW91dHNpZGUuZGlyZWN0aXZlJztcbiJdfQ==

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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