@alauda-fe/common 1.0.0-next.0

package/code/public-api.d.ts

@@ -0,0 +1,11 @@
+/**
+ * [[include:code/README.md]]
+ * @module code
+ * @preferred
+ */
+/** imports */
+export * from './code.module';
+export * from './code-display-dialog/component';
+export * from './code-editor-configs';
+export * from './k8s-yaml-display-dialog/component';
+export * from './resource-yaml-display/component';

package/code/resource-yaml-display/component.d.ts

@@ -0,0 +1,22 @@
+import { BehaviorSubject, Observable } from 'rxjs';
+import { YamlUtilService } from '../../core/services/yaml-util.service';
+import { Arrayable } from '../../core/types/helpers';
+import { KubernetesResource } from '../../core/types/k8s';
+import * as i0 from "@angular/core";
+export declare class ResourceYamlDisplayComponent<T extends KubernetesResource> {
+    private readonly yamlUtil;
+    concise$$: BehaviorSubject<boolean>;
+    reduce$$: BehaviorSubject<boolean>;
+    hasWrapper: boolean;
+    conciseEnable: boolean;
+    manageFieldActionEnable: boolean;
+    resource: Arrayable<T>;
+    readonly resource$: Observable<Arrayable<T>>;
+    constructor(yamlUtil: YamlUtilService);
+    yaml$: Observable<string>;
+    editorOptions: import("../code-editor-configs").IEditorConstructionOptions;
+    viewActions: import("@alauda/code-editor").CodeEditorActionsConfig;
+    conciseChange(value: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ResourceYamlDisplayComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ResourceYamlDisplayComponent<any>, "acl-resource-yaml-display", never, { "hasWrapper": { "alias": "hasWrapper"; "required": false; }; "conciseEnable": { "alias": "conciseEnable"; "required": false; }; "manageFieldActionEnable": { "alias": "manageFieldActionEnable"; "required": false; }; "resource": { "alias": "resource"; "required": false; }; }, {}, never, never, false, never>;
+}

package/core/abstract/base-form-container.d.ts

@@ -0,0 +1,41 @@
+import { NotificationService } from '@alauda/ui';
+import { Location } from '@angular/common';
+import { Injector, OnInit } from '@angular/core';
+import { FormBuilder, FormGroup } from '@angular/forms';
+import { Observable } from 'rxjs';
+import { InterceptDeactivateService } from '..';
+import * as i0 from "@angular/core";
+/**
+ * http://confluence.alauda.cn/display/FRON/Issue-Angular+related
+ * 由于formControl存在内存泄漏问题，内部 form 展示-隐藏切换应当采用 hidden 进行控制
+ */
+export declare abstract class BaseFormContainer<T = any> implements OnInit {
+    isUpdate: boolean;
+    initResource: T;
+    initResource$: Observable<T>;
+    private readonly ngForm;
+    codeEditorOptions: import("../../code/code-editor-configs").IEditorConstructionOptions;
+    actionsConfig: import("@alauda/code-editor").CodeEditorActionsConfig;
+    formView: 'UI' | 'YAML';
+    submitting: boolean;
+    resource: T;
+    yaml: string;
+    originalYaml: string;
+    fb: FormBuilder;
+    interceptDeactivate: InterceptDeactivateService;
+    form: FormGroup;
+    protected notification: NotificationService;
+    protected location: Location;
+    protected fillResource: (resource: T) => T;
+    abstract submit(): void;
+    constructor(injector: Injector);
+    ngOnInit(): void;
+    switchFormView(view: 'YAML' | 'UI'): void;
+    cancel(escape?: boolean): void;
+    protected checkForm(): boolean;
+    protected yamlToResource(yaml: string): T;
+    protected resourceToYaml(resource: T): string;
+    protected updateResource(resource: T): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaseFormContainer<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BaseFormContainer<any>, never, never, { "isUpdate": { "alias": "isUpdate"; "required": false; }; "initResource": { "alias": "initResource"; "required": false; }; }, {}, never, never, false, never>;
+}

package/core/abstract/base-nested-form-control.d.ts

@@ -0,0 +1,58 @@
+import { AfterViewInit, ChangeDetectorRef, OnDestroy, QueryList } from '@angular/core';
+import { AbstractControl, ControlValueAccessor, FormGroupDirective, NgControl, NgForm, ValidationErrors } from '@angular/forms';
+import { ReplaySubject, Subject, Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+export declare function createNestedFormControl<V, M = V>({ autoEmitChange, asyncValidator, }?: {
+    autoEmitChange?: boolean;
+    asyncValidator?: boolean;
+}): new () => BaseNestedFormControl<V, M>;
+export declare class BaseNestedFormControl<V, M = V> implements AfterViewInit, OnDestroy, ControlValueAccessor {
+    protected controls: QueryList<NgControl>;
+    get disabled(): boolean | '';
+    set disabled(val: boolean | '');
+    private _disabled;
+    onValidatorChange: () => void;
+    onChange: (_: V) => void;
+    onTouched: () => void;
+    onSubmitted: () => void;
+    model: M;
+    submitted: boolean;
+    protected autoEmitChange: boolean;
+    protected asyncValidator: boolean;
+    protected cdr: ChangeDetectorRef;
+    protected destroy$$: Subject<void>;
+    protected hostForm: NgForm | FormGroupDirective;
+    constructor();
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    registerOnValidatorChange(fn: () => void): void;
+    registerOnChange(fn: (_: V) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    writeValue(value: V): void;
+    validate(_control?: AbstractControl): ValidationErrors | null | Observable<ValidationErrors | null>;
+    emitModel(model?: M): void;
+    emitValue(value: V): void;
+    protected valueIn(value: V): M;
+    protected modelOut(model: M): V;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaseNestedFormControl<any, any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BaseNestedFormControl<any, any>, never, never, { "disabled": { "alias": "disabled"; "required": false; }; }, {}, never, never, false, never>;
+}
+/**
+ * @deprecated use {@link BaseNestedFormControl} instead.
+ */
+export declare class BaseNestedFormControlPure<V, M = V> extends BaseNestedFormControl<V, M> {
+    model$: ReplaySubject<M>;
+    constructor();
+    writeValue(value: V): void;
+    emitValue(value: V): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaseNestedFormControlPure<any, any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BaseNestedFormControlPure<any, any>, never, never, {}, {}, never, never, false, never>;
+}
+type Path = string | Array<string | number>;
+interface Mapper {
+    [x: string]: Mapper | Path;
+}
+export declare function dataTransfer<S extends object, T extends object, M extends Record<keyof T, Path | Mapper> = Record<keyof T, Path | Mapper>>(mapper: M): [(source: S) => T, (target: T) => S];
+export declare function copyValue<T extends object>(from: Path, to: Path, mapper?: (v: any) => any): (object: T) => T;
+export {};

package/core/abstract/index.d.ts

@@ -0,0 +1,2 @@
+export * from './base-form-container';
+export * from './base-nested-form-control';

package/core/components/index.d.ts

@@ -0,0 +1 @@
+export * from './tree';

package/core/components/tree/index.d.ts

@@ -0,0 +1 @@
+export * from './public-api';

package/core/components/tree/module.d.ts

@@ -0,0 +1,12 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./tree/component";
+import * as i2 from "./node/component";
+import * as i3 from "./padding";
+import * as i4 from "./outlet";
+import * as i5 from "./toggle";
+import * as i6 from "@angular/common";
+export declare class TreeViewModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<TreeViewModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<TreeViewModule, [typeof i1.TreeComponent, typeof i2.TreeNodeDefDirective, typeof i3.TreeNodePaddingDirective, typeof i4.TreeNodeOutletDirective, typeof i5.TreeNodeToggleDirective, typeof i2.NestedTreeNodeComponent], [typeof i6.CommonModule], [typeof i1.TreeComponent, typeof i2.TreeNodeDefDirective, typeof i3.TreeNodePaddingDirective, typeof i4.TreeNodeOutletDirective, typeof i5.TreeNodeToggleDirective, typeof i2.NestedTreeNodeComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<TreeViewModule>;
+}

package/core/components/tree/node/component.d.ts

@@ -0,0 +1,12 @@
+import { CdkNestedTreeNode, CdkTreeNodeDef } from '@angular/cdk/tree';
+import * as i0 from "@angular/core";
+export declare class NestedTreeNodeComponent<T> extends CdkNestedTreeNode<T> {
+    createAsyncNodes(nodes: T[]): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NestedTreeNodeComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NestedTreeNodeComponent<any>, "acl-nested-tree-node", ["aclNestedTreeNode"], {}, {}, never, ["*"], false, never>;
+}
+export declare class TreeNodeDefDirective<T> extends CdkTreeNodeDef<T> {
+    when: (index: number, nodeData: T) => boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TreeNodeDefDirective<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TreeNodeDefDirective<any>, "[aclTreeNodeDef]", never, { "when": { "alias": "aclTreeNodeDefWhen"; "required": false; }; }, {}, never, never, false, never>;
+}

package/core/components/tree/outlet.d.ts

@@ -0,0 +1,10 @@
+import { CdkTreeNodeOutlet } from '@angular/cdk/tree';
+import { ViewContainerRef } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class TreeNodeOutletDirective implements CdkTreeNodeOutlet {
+    viewContainer: ViewContainerRef;
+    _node?: any;
+    constructor(viewContainer: ViewContainerRef, _node?: any);
+    static ɵfac: i0.ɵɵFactoryDeclaration<TreeNodeOutletDirective, [null, { optional: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TreeNodeOutletDirective, "[aclTreeNodeOutlet]", never, {}, {}, never, never, false, never>;
+}

package/core/components/tree/padding.d.ts

@@ -0,0 +1,12 @@
+import { NumberInput } from '@angular/cdk/coercion';
+import { CdkTreeNodePadding } from '@angular/cdk/tree';
+import * as i0 from "@angular/core";
+export declare class TreeNodePaddingDirective<T> extends CdkTreeNodePadding<T> {
+    _indent: number;
+    get level(): number;
+    set level(value: NumberInput);
+    get indent(): number | string;
+    set indent(indent: number | string);
+    static ɵfac: i0.ɵɵFactoryDeclaration<TreeNodePaddingDirective<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TreeNodePaddingDirective<any>, "[aclTreeNodePadding]", never, { "level": { "alias": "aclTreeNodePadding"; "required": false; }; "indent": { "alias": "aclTreeNodePaddingIndent"; "required": false; }; }, {}, never, never, false, never>;
+}

package/core/components/tree/public-api.d.ts

@@ -0,0 +1,6 @@
+export * from './tree/component';
+export * from './node/component';
+export * from './outlet';
+export * from './padding';
+export * from './toggle';
+export * from './module';

package/core/components/tree/toggle.d.ts

@@ -0,0 +1,12 @@
+import { CdkTreeNodeToggle } from '@angular/cdk/tree';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+export declare class TreeNodeToggleDirective<T> extends CdkTreeNodeToggle<T> {
+    get recursive(): boolean;
+    set recursive(value: boolean);
+    aclTreeNodeToggleObservable: () => Observable<boolean>;
+    get isExpanded(): boolean;
+    _toggle(event: Event): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TreeNodeToggleDirective<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TreeNodeToggleDirective<any>, "[aclTreeNodeToggle]", never, { "recursive": { "alias": "aclTreeNodeToggleRecursive"; "required": false; }; "aclTreeNodeToggleObservable": { "alias": "aclTreeNodeToggleObservable"; "required": false; }; }, {}, never, never, false, never>;
+}

package/core/components/tree/tree/component.d.ts

@@ -0,0 +1,8 @@
+import { CdkTree } from '@angular/cdk/tree';
+import { TreeNodeOutletDirective } from '../outlet';
+import * as i0 from "@angular/core";
+export declare class TreeComponent<T, K> extends CdkTree<T, K> {
+    _nodeOutlet: TreeNodeOutletDirective;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TreeComponent<any, any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TreeComponent<any, any>, "acl-tree", ["aclTree"], {}, {}, never, never, false, never>;
+}

package/core/constants/constants.d.ts

@@ -0,0 +1,61 @@
+/**
+ * @packageDocumentation
+ * @module utils
+ */
+export declare const API_GATEWAY = "{{API_GATEWAY}}";
+export declare const TRUE = "true";
+export declare const FALSE = "false";
+export declare const EMPTY = "";
+export declare const SPACE = " ";
+export declare const DOT = ".";
+export declare const SLASH = "/";
+export declare const HYPHEN = "-";
+export declare const UNDERSCORE = "_";
+export declare const DELIMITER = ":";
+export declare const WILDCARD = ".*";
+export declare const DATE_FORMAT = "YYYY-MM-DD";
+export declare const TIME_FORMAT = "HH:mm:ss";
+export declare const DATE_TIME_FORMAT: string;
+export declare const WORKSPACE_PARAMS = "workspace_params_v1";
+export declare const PUBLIC_NAMESPACE = "kube-public";
+export declare const Bracket: {
+    readonly PARENTHESES: readonly ["(", ")"];
+    readonly BRACES: readonly ["{", "}"];
+    readonly SQUARE_BRACKETS: readonly ["[", "]"];
+    readonly POINTY_BRACKETS: readonly ["<", ">"];
+};
+export declare const TEMPLATE_OPTIONS: Readonly<{
+    interpolate: RegExp;
+}>;
+export declare const DEFAULT_CODE_EDITOR_OPTIONS: import('@alauda/code-editor').MonacoEditorOptions;
+export declare const NOTIFY_ON_ERROR_HEADER = "__NOTIFICATION_ON_ERROR__";
+export declare const NOTIFY_DURATION_HEADER = "__NOTIFICATION_DURATION__";
+export declare const NOTIFY_ON_ERROR_HEADERS: {
+    readonly __NOTIFICATION_ON_ERROR__: "true";
+};
+export declare const NOT_NOTIFY_ON_ERROR_HEADERS: {
+    readonly __NOTIFICATION_ON_ERROR__: "false";
+};
+export declare const DOWNGRADE_WATCH_ENABLED: boolean;
+export declare const DOWNGRADE_WATCH_POLLING: 5000;
+export declare const CREATED_AT = "created_at";
+export declare const UPDATED_AT = "updated_at";
+export declare const ACTION = "action";
+export declare const SPEC = "spec";
+export declare const CREATE = "create";
+export declare const UPDATE = "update";
+export declare const LINK = "link";
+export declare const ESCAPE_DEACTIVATE_CHECK = "escape";
+export declare const CUSTOMIZED = "customized";
+export declare const GLOBAL_CLUSTER = "global";
+export declare const PACKAGE_RUNTIME_VALUE = "Runtime";
+export declare const CRYPTO_HEADER_KEY = "X-Param-Response";
+export declare enum CRYPTO_TYPE {
+    Enable = "Force",
+    Drop = "Drop",
+    Disable = "None"
+}
+export declare const CRYPTO_RANDOM_HEADER_KEY = "X-Param-Init";
+export declare const CRYPTO_KEY = "alauda";
+export declare const PLATFORM_OPS_MODE = "platform-ops-mode";
+export declare const DEFAULT_CONTAINER_ANNOTATION = "kubectl.kubernetes.io/default-container";

package/core/constants/index.d.ts

@@ -0,0 +1,5 @@
+export * from './constants';
+export * from './patterns';
+export * from './status-icons';
+export * from './tokens';
+export * from './timezones';

package/core/constants/patterns.d.ts

@@ -0,0 +1,25 @@
+export declare const K8S_RESOURCE_NAME_BASE: {
+    pattern: RegExp;
+    tip: string;
+};
+export declare const IP_ADDRESS_PATTERN: {
+    pattern: RegExp;
+    placeholder: string;
+    tip: string;
+};
+export declare const HTTP_IP_OR_DOMAIN_PATTERN: {
+    pattern: RegExp;
+    tip: string;
+};
+export declare const HTTP_DUAL_IP_OR_DOMAIN_PATTERN: {
+    pattern: RegExp;
+    tip: string;
+};
+export declare const HTTP_ADDRESS_PATTERN: {
+    pattern: RegExp;
+    tip: string;
+};
+export declare const EMAIL_PATTERN: {
+    pattern: RegExp;
+    tip: string;
+};

package/core/constants/status-icons.d.ts

@@ -0,0 +1,28 @@
+export declare enum GenericStatusIcon {
+    Check = "check_circle_s",
+    Running = "arrow_right_circle_s",
+    Error = "xmark_circle_s",
+    Stopped = "stop_circle_s",
+    Pending = "rotate_circle_s",
+    Question = "question_circle_s",
+    Exclamation = "exclamation_circle_s",
+    Warning = "exclamation_triangle_s",
+    Deleting = "trash_circle_s",
+    Invalid = "minus_circle_s",
+    Pause = "pause_circle_s",
+    Alarm = "siren",
+    Upgradeable = "prod:upgradable_s",
+    Provisioning = "hourglass_circle_s",
+    Circle = "circle",
+    Healthy = "prod:heart_pulse_circle_s"
+}
+export declare enum GenericStatusColor {
+    Pending = "rgb(var(--aui-color-blue))",
+    Running = "rgb(var(--aui-color-green))",
+    Succeeded = "rgb(var(--aui-color-green))",
+    Warning = "rgb(var(--aui-color-yellow))",
+    Failed = "rgb(var(--aui-color-red))",
+    Stopped = "rgb(var(--aui-color-n-3))",
+    Empty = "rgb(var(--aui-color-n-4))",
+    Missing = "rgb(var(--aui-color-n-6))"
+}

package/core/constants/timezones.d.ts

@@ -0,0 +1,6 @@
+export declare const BASE_TIMEZONE = "Etc/UTC";
+export declare const TIMEZONES: {
+    name: string;
+    name_zh: string;
+    tzCode: string;
+}[];

package/core/constants/tokens.d.ts

@@ -0,0 +1,44 @@
+/**
+ * @packageDocumentation
+ * @module utils
+ */
+import { InjectionToken } from '@angular/core';
+import { K8sResourceDefinitions } from '../../api/types';
+import { Environments } from '../types/commons';
+export declare const idTokenKey = "id_token";
+export declare const refreshTokenKey = "refresh_token";
+export declare const codeKey = "code";
+export declare const anonymousApis: Array<string | RegExp>;
+export declare const modulesApi = "/console/api/v1/modules";
+export declare const tokenLoginApi = "/console/api/v1/token/login";
+export declare const tokenCallbackApi = "/console/api/v1/token/callback";
+export declare const tokenRefreshApi = "/console/api/v1/token/refresh";
+export declare const tokenInfoApi = "/console/api/v1/token/info";
+export declare const tokenNonAdminRedirectPath = "/";
+export declare const resourceDefinitions: K8sResourceDefinitions;
+export declare function initGlobalEnvironments(env: Environments): void;
+export declare function fetchGlobalEnvironments(callback: () => void): void;
+export declare function getGlobalEnvironments(): Readonly<Environments>;
+export declare function getGlobalEnvironments<T extends keyof Environments>(name: T): Environments[T];
+export declare const ANONYMOUS_APIS: InjectionToken<(string | RegExp)[]>;
+export declare const ID_TOKEN_KEY: InjectionToken<string>;
+export declare const REFRESH_TOKEN_KEY: InjectionToken<string>;
+export declare const CODE_KEY: InjectionToken<string>;
+export declare const MODULES_API: InjectionToken<string>;
+export declare const TOKEN_LOGIN_API: InjectionToken<string>;
+export declare const TOKEN_CALLBACK_API: InjectionToken<string>;
+export declare const TOKEN_REFRESH_API: InjectionToken<string>;
+export declare const TOKEN_INFO_API: InjectionToken<string>;
+export declare const TOKEN_NON_ADMIN_REDIRECT_PATH: InjectionToken<string>;
+export declare const TOKEN_BASE_DOMAIN: InjectionToken<string>;
+export declare const TOKEN_GLOBAL_NAMESPACE: InjectionToken<string>;
+export declare const TOKEN_LOGO_URL: InjectionToken<string>;
+export declare const TOKEN_RESOURCE_DEFINITIONS: InjectionToken<Readonly<Record<string, Readonly<{
+    type: string;
+    apiGroup?: string;
+    apiVersion?: string;
+}>>>>;
+export declare const TOKEN_BASE_HREF: InjectionToken<string>;
+export declare const TOKEN_DOCS_BASE_HREF: InjectionToken<string>;
+export declare const TOKEN_DISABLE_SESSION_MANAGE: InjectionToken<boolean>;
+export declare const TOKEN_CRYPTO_INTERCEPTOR_URL_REGEXPS: InjectionToken<any[]>;

package/core/directives/click-outside.directive.d.ts

@@ -0,0 +1,12 @@
+import { ElementRef, EventEmitter, OnInit } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class ClickOutsideDirective implements OnInit {
+    private readonly el;
+    className: string;
+    clickOutside: EventEmitter<Event>;
+    onBodyClick(event: MouseEvent): void;
+    constructor(el: ElementRef<HTMLElement>);
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClickOutsideDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ClickOutsideDirective, "[aclClickOutside]", ["aclClickOutside"], { "className": { "alias": "aclClickOutside"; "required": false; }; }, { "clickOutside": "clickOutside"; }, never, never, true, never>;
+}

package/core/directives/disabled.directive.d.ts

@@ -0,0 +1,28 @@
+import { AttrBoolean } from '@alauda/ui';
+import { OnDestroy, OnInit } from '@angular/core';
+import { ControlContainer, NgControl } from '@angular/forms';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+/**
+ *
+ * Usage:
+ * If you want to disable a formControl.
+ *
+ * eg:
+ * <input formControlName="name" [aclDisabled]="true">
+ *
+ */
+export declare class DisabledDirective implements OnInit, OnDestroy {
+    private readonly ctrlContainer;
+    private readonly ngControl;
+    aclDisabled: AttrBoolean;
+    aclDisabled$: Observable<AttrBoolean>;
+    destroyStrategy?: 'check' | 'disable' | 'enable';
+    private readonly destroy$$;
+    constructor(ctrlContainer: ControlContainer, ngControl: NgControl);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    private checkStatus;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DisabledDirective, [{ optional: true; self: true; }, { optional: true; self: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DisabledDirective, "[aclDisabled]", never, { "aclDisabled": { "alias": "aclDisabled"; "required": false; }; "destroyStrategy": { "alias": "destroyStrategy"; "required": false; }; }, {}, never, never, true, never>;
+}

package/core/directives/feature-gate.directive.d.ts

@@ -0,0 +1,30 @@
+/**
+ * @packageDocumentation
+ * @module utils
+ */
+import { ChangeDetectorRef, OnDestroy, OnInit, TemplateRef, ViewContainerRef } from '@angular/core';
+import { FeatureGateService } from '../services/feature-gate.service';
+import * as i0 from "@angular/core";
+/**
+ * @example
+ * ```
+ * <ng-container *aclFeatureGate="gate-name"></ng-container>
+ * ```
+ */
+export declare class FeatureGateDirective implements OnInit, OnDestroy {
+    private readonly container;
+    private readonly featureGate;
+    private readonly crd;
+    featureName: string;
+    cluster: string;
+    set then(templateRef: TemplateRef<void>);
+    set else(templateRef: TemplateRef<void>);
+    private thenTemplateRef;
+    private elseTemplateRef;
+    private subscription;
+    constructor(container: ViewContainerRef, featureGate: FeatureGateService, crd: ChangeDetectorRef, templateRef: TemplateRef<void>);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FeatureGateDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FeatureGateDirective, "[aclFeatureGate]", never, { "featureName": { "alias": "aclFeatureGate"; "required": false; }; "cluster": { "alias": "aclFeatureGateCluster"; "required": false; }; "then": { "alias": "aclFeatureGateThen"; "required": false; }; "else": { "alias": "aclFeatureGateElse"; "required": false; }; }, {}, never, never, false, never>;
+}

package/core/directives/index.d.ts

@@ -0,0 +1,10 @@
+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';

package/core/directives/intercept-deactivate.directive.d.ts

@@ -0,0 +1,18 @@
+import { AfterViewInit, ElementRef, OnDestroy } from '@angular/core';
+import { Observable, Subject } from 'rxjs';
+import { InterceptDeactivateService } from '../services/intercept-deactivate.service';
+import * as i0 from "@angular/core";
+export declare class InterceptDeactivateDirective implements AfterViewInit, OnDestroy {
+    private readonly elRef;
+    private readonly interceptDeactivate;
+    enabled: boolean | '';
+    enabled$$: Observable<boolean | ''>;
+    enabled$: Observable<boolean>;
+    destroy$$: Subject<void>;
+    constructor(elRef: ElementRef<HTMLElement>, interceptDeactivate: InterceptDeactivateService);
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    onBeforeUnload(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InterceptDeactivateDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<InterceptDeactivateDirective, "[aclInterceptDeactivate]", never, { "enabled": { "alias": "aclInterceptDeactivate"; "required": false; }; }, {}, never, never, true, never>;
+}

package/core/directives/last-form-item.directive.d.ts

@@ -0,0 +1,8 @@
+import { ElementRef } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class FormItemMarginEffectDirective {
+    private readonly el;
+    constructor(el: ElementRef);
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormItemMarginEffectDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FormItemMarginEffectDirective, "[aclFormItemEffect]", never, {}, {}, never, never, false, never>;
+}

package/core/directives/page-header-content.directive.d.ts

@@ -0,0 +1,25 @@
+import { OnDestroy, OnInit, TemplateRef, ViewContainerRef } from '@angular/core';
+import { TemplateHolder, UiStateService } from '../services/ui-state.service';
+import * as i0 from "@angular/core";
+/**
+ * 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 declare class PageHeaderContentDirective implements OnInit, OnDestroy {
+    private readonly templateRef;
+    private readonly viewContainerRef;
+    private readonly uiState;
+    templateHolder: TemplateHolder;
+    constructor(templateRef: TemplateRef<any>, viewContainerRef: ViewContainerRef, uiState: UiStateService);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PageHeaderContentDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<PageHeaderContentDirective, "[aclPageHeaderContent]", never, {}, {}, never, never, true, never>;
+}

package/core/directives/readonly-field.directive.d.ts

@@ -0,0 +1,39 @@
+/**
+ * @packageDocumentation
+ * @module utils
+ */
+import { FormItemControlDirective } from '@alauda/ui';
+import { ComponentFactoryResolver, OnDestroy, OnInit, TemplateRef, ViewContainerRef } from '@angular/core';
+import { NgControl } from '@angular/forms';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+export declare class ReadonlyFieldDirective implements OnInit, OnDestroy {
+    private readonly control;
+    private readonly cfr;
+    private readonly viewContainerRef;
+    private readonly controlDirective;
+    aclReadonlyField: boolean;
+    aclReadonlyField$: Observable<boolean>;
+    hidden: boolean;
+    private isControlRequired;
+    private spanComponentRef;
+    private readonly templateContext;
+    private readonly destroy$;
+    template: TemplateRef<any>;
+    context: object;
+    get isHidden(): boolean;
+    constructor(control: NgControl, cfr: ComponentFactoryResolver, viewContainerRef: ViewContainerRef, controlDirective: FormItemControlDirective);
+    private setValue;
+    ngOnInit(): void;
+    private applyValidators;
+    private clearValidators;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ReadonlyFieldDirective, [null, null, null, { optional: true; self: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ReadonlyFieldDirective, "[aclReadonlyField]", never, { "aclReadonlyField": { "alias": "aclReadonlyField"; "required": false; }; "hidden": { "alias": "hidden"; "required": false; }; "template": { "alias": "aclReadonlyFieldTemplate"; "required": false; }; "context": { "alias": "aclReadonlyFieldTemplateContext"; "required": false; }; }, {}, never, never, true, never>;
+}
+export declare class SpanComponent<T = unknown> {
+    data: T;
+    setData(value: T): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SpanComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SpanComponent<any>, "ng-component", never, {}, {}, never, never, false, never>;
+}

package/core/directives/resize.directive.d.ts

@@ -0,0 +1,17 @@
+import { AfterViewInit, ElementRef, EventEmitter, OnDestroy } from '@angular/core';
+import * as i0 from "@angular/core";
+export interface ResizeEvent {
+    width: number;
+    height: number;
+}
+export declare class ResizeDirective implements OnDestroy, AfterViewInit {
+    private readonly element;
+    resized: EventEmitter<ResizeEvent>;
+    private readonly destroy$$;
+    constructor(element: ElementRef);
+    ngAfterViewInit(): void;
+    private onResized;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ResizeDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ResizeDirective, "[aclResize]", never, {}, { "resized": "resized"; }, never, never, true, never>;
+}

package/core/directives/scroll-border-observer.directive.d.ts

@@ -0,0 +1,23 @@
+import { EventEmitter, Injector, OnDestroy, OnInit } from '@angular/core';
+import { Subject } from 'rxjs';
+import * as i0 from "@angular/core";
+interface Option {
+    bottomDistance?: number;
+    topDistance?: number;
+}
+export declare class ScrollBorderObserverDirective implements OnInit, OnDestroy {
+    option: Option | '' | false | number;
+    scrollBorder: EventEmitter<"top" | "bottom">;
+    scrollBottomBorder: EventEmitter<any>;
+    scrollEl: HTMLElement | Window;
+    readonly destroy$$: Subject<void>;
+    private readonly scrollDispatcher;
+    private readonly viewContainerRef;
+    constructor(injector: Injector);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    private setupScroll;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ScrollBorderObserverDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ScrollBorderObserverDirective, "[aclScrollBorderObserver]", never, { "option": { "alias": "aclScrollBorderObserver"; "required": false; }; }, { "scrollBorder": "scrollBorder"; "scrollBottomBorder": "scrollBottomBorder"; }, never, never, true, never>;
+}
+export {};