@alauda-fe/common 1.0.0-next.0

package/core/services/custom-code-editor-intl.service.d.ts

@@ -0,0 +1,33 @@
+import { CodeEditorIntl } from '@alauda/code-editor';
+import { TranslateService } from '../../translate/translate.service';
+import * as i0 from "@angular/core";
+/**
+ * aui-code-editor 中 label 翻译依赖 CodeEditorIntl 中的具体属性值
+ */
+export declare class CustomCodeEditorIntl extends CodeEditorIntl {
+    translate: TranslateService;
+    labels$: import("rxjs").Observable<{
+        copyLabel: string;
+        copiedLabel: string;
+        readonlyLabel: string;
+        readwriteLabel: string;
+        clearLabel: string;
+        recoverLabel: string;
+        findLabel: string;
+        formatLabel: string;
+        foldLabel: string;
+        exportLabel: string;
+        importLabel: string;
+        lightThemeLabel: string;
+        darkThemeLabel: string;
+        autoThemeLabel: string;
+        showDiffLabel: string;
+        fullscreenLabel: string;
+        exitFullscreenLabel: string;
+        previewLabel: string;
+    }>;
+    getLanguageLabel(lang: string): string;
+    constructor(translate: TranslateService);
+    static ɵfac: i0.ɵɵFactoryDeclaration<CustomCodeEditorIntl, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CustomCodeEditorIntl>;
+}

package/core/services/feature-gate.service.d.ts

@@ -0,0 +1,35 @@
+/**
+ * @packageDocumentation
+ * @module utils
+ */
+import { HttpClient } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+export declare class FeatureGateService {
+    private readonly http;
+    private readonly cacheStore;
+    constructor(http: HttpClient);
+    loadState(cluster?: string): Observable<"loaded" | "loadFailed" | "loading">;
+    /**
+     * check gate status
+     * @param gate - specified feature gate
+     * @param cluster - check gate for specified cluster
+     */
+    isEnabled(gateName: string, cluster?: string): Observable<boolean>;
+    /**
+     * filter list with gate, send items without feature gate as begin push (can skip by passing `skipNoFeatureGatePush` argument with true)
+     * @param items - list need filter
+     * @param gateAccessor - how to get gate from item
+     * @param cluster - check gate for specified cluster
+     * @param filterMethod - filter method, default to list filter, can filter deep with createRecursiveFilter or totally custom method.
+     * @param skipNoFeatureGatePush - skip begin push , default false.
+     */
+    filterEnabled<T>(items: T[], gateAccessor: (item: T) => string, cluster?: string, filterMethod?: (items: T[], condition: (item: T) => boolean) => T[], skipNoFeatureGatePush?: boolean): Observable<T[]>;
+    /**
+     * refetch cached feature gate settings
+     * @param cluster - specified cluster, refetch all already cached settings when cluster is empty
+     */
+    refetchCache(cluster?: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FeatureGateService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FeatureGateService>;
+}

package/core/services/form-row-duplicate/form-row-duplicate.service.d.ts

@@ -0,0 +1,45 @@
+import { IterableDiffers, OnDestroy } from '@angular/core';
+import { AbstractControl, FormArray, ValidatorFn } from '@angular/forms';
+import * as i0 from "@angular/core";
+export declare const DUPLICATE_ERROR_KEY = "duplicateError";
+type RowKeys = Array<string | Record<string, string[]>>;
+type FormatKeys = Record<string, string[]>;
+export type FormatValue = Record<string, any>;
+export type MatchValueFn = (props: string[], value1: FormatValue, value2: FormatValue) => boolean;
+export type StrategyFn = (keys: FormatKeys, controls: AbstractControl[], staleValue: FormatValue, mapFn: ValueMapFn, matchesFn: MatchValueFn, initData: any[]) => Array<{
+    key: string;
+    control: AbstractControl;
+}>;
+export declare enum DUPLICATION_JUSTIFY_STRATEGY {
+    IDENTICAL = "identical",
+    FULL = "full"
+}
+export declare const STRATEGY_JUDGE_MAPPER: Record<DUPLICATION_JUSTIFY_STRATEGY, StrategyFn>;
+export declare class ValidateRowDuplicateService implements OnDestroy {
+    private readonly arrayDiffers;
+    private rowsDiffer;
+    /**
+     * @param differFactory: used to create support differ, which can be provided by user
+     */
+    constructor(arrayDiffers: IterableDiffers);
+    private readonly controlValueMap;
+    private readonly errorMap;
+    private formArraySizeSub;
+    createFormArrayValidator({ rowKeys, formArray, valueMapFn, initData, matchesFn, strategy, }: {
+        rowKeys: RowKeys;
+        formArray: FormArray;
+        valueMapFn?: any;
+        initData?: any[];
+        matchesFn?: MatchValueFn;
+        strategy?: DUPLICATION_JUSTIFY_STRATEGY;
+    }): ValidatorFn;
+    private handleRemoveRowValue;
+    private initFormArraySizeChange;
+    private addDuplicateError;
+    private removeDuplicateError;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ValidateRowDuplicateService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ValidateRowDuplicateService>;
+}
+type ValueMapFn = (data: any, prop?: string) => any;
+export {};

package/core/services/index.d.ts

@@ -0,0 +1,14 @@
+export * from './aui-paginator-intl.service';
+export * from './aui-tooltip-copy-intl.service';
+export * from './custom-code-editor-intl.service';
+export * from './feature-gate.service';
+export * from './intercept-deactivate.service';
+export * from './k8s-util.service';
+export * from './silently-navigate.service';
+export * from './time.service';
+export * from './ui-state.service';
+export * from './workspace-helper.service';
+export * from './on-resize.service';
+export * from './yaml-util.service';
+export * from './form-row-duplicate/form-row-duplicate.service';
+export * from './context.service';

package/core/services/intercept-deactivate.service.d.ts

@@ -0,0 +1,28 @@
+import { DialogService } from '@alauda/ui';
+import { Location } from '@angular/common';
+import { OnDestroy } from '@angular/core';
+import { Router } from '@angular/router';
+import { Subject } from 'rxjs';
+import { TranslateService } from '../../translate/translate.service';
+import * as i0 from "@angular/core";
+export declare class InterceptDeactivateService implements OnDestroy {
+    private readonly location;
+    private readonly router;
+    private readonly dialog;
+    private readonly translate;
+    destroy$$: Subject<void>;
+    constructor(location: Location, router: Router, dialog: DialogService, translate: TranslateService);
+    ngOnDestroy(): void;
+    intercept({ title, content, context, errorFallback, }?: {
+        title?: string;
+        content?: string;
+        context?: unknown;
+        errorFallback?: boolean;
+    }): import("rxjs").Observable<boolean>;
+    back(escape?: boolean): Promise<void>;
+    forward(escape?: boolean): Promise<void>;
+    searchParamsToQueryParams(searchParams: URLSearchParams): Record<string, string | string[]>;
+    escape(): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InterceptDeactivateService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<InterceptDeactivateService>;
+}

package/core/services/k8s-util.service.d.ts

@@ -0,0 +1,78 @@
+/**
+ * @packageDocumentation
+ * @module utils
+ */
+import { DialogService, MessageService } from '@alauda/ui';
+import { Injector } from '@angular/core';
+import { Observable } from 'rxjs';
+import { K8sApiService, ResourceDeleteParams } from '../../api/public-api';
+import { KubernetesResource, Status } from '../../core/types';
+import { TranslateService } from '../../translate/translate.service';
+import * as i0 from "@angular/core";
+export declare const METADATA = "metadata";
+export declare const NAMESPACE = "namespace";
+export declare const NAME = "name";
+export declare const CREATION_TIMESTAMP = "creationTimestamp";
+export declare const ANNOTATIONS = "annotations";
+export declare const LABELS = "labels";
+export declare const DISPLAY_NAME = "display-name";
+export declare const DESCRIPTION = "description";
+export declare const CREATOR = "creator";
+export declare const UPDATED__AT = "updated-at";
+export declare const PROJECT = "project";
+export declare const CLUSTER = "cluster";
+export declare const TRANSLATION = "translation";
+export interface BaseNormalizeTypeParams {
+    type: string;
+    baseDomain: string;
+    prefix?: string;
+}
+export declare class K8sUtilService<R extends string = string> {
+    protected injector: Injector;
+    protected dialog: DialogService;
+    protected message: MessageService;
+    protected k8sApi: K8sApiService<R>;
+    protected translate: TranslateService;
+    protected baseDomain: string;
+    constructor(injector: Injector);
+    /**
+     * @param type - 对应资源的翻译 key
+     */
+    deleteResource<T extends KubernetesResource>(params: ResourceDeleteParams<R, T>, typeOrOptions: string | {
+        type: string;
+        content: string;
+    }): Observable<Status>;
+    updateResource<T extends KubernetesResource>({ type, cluster, resource, silent, }: {
+        type: R;
+        cluster: string;
+        resource: T;
+        silent?: boolean;
+    }): Observable<T>;
+    updateGlobalResource<T extends KubernetesResource>({ type, namespaced, resource, namespace, silent, }: {
+        type: R;
+        namespaced?: boolean;
+        resource: T;
+        namespace?: string;
+        silent?: boolean;
+    }): Observable<T>;
+    normalizeType(type: string, prefix?: string): string;
+    normalizeType(params: BaseNormalizeTypeParams): string;
+    getAnnotation<T extends KubernetesResource>(resource: T, type: string, prefix?: string): string;
+    getAnnotation<T extends KubernetesResource>(resource: T, params: BaseNormalizeTypeParams): string;
+    getNamespace<T extends KubernetesResource>(resource: T): T["metadata"]["namespace"];
+    getName<T extends KubernetesResource>(resource: T): T["metadata"]["name"];
+    getCreationTimestamp<T extends KubernetesResource>(resource: T): T["metadata"]["creationTimestamp"];
+    getDisplayName<T extends KubernetesResource>(resource: T, prefix?: string): string;
+    getUnionDisplayName<T extends KubernetesResource>(resource: T, namePrefix?: string | false, displayNamePrefix?: string): string;
+    getDescription<T extends KubernetesResource>(resource: T, prefix?: string): string;
+    getCreator<T extends KubernetesResource>(resource: T, prefix?: string): string;
+    getUpdatedAt<T extends KubernetesResource>(resource: T, prefix?: string): string;
+    getLabel<T extends KubernetesResource>(resource: T, type: string, prefix?: string): string;
+    getLabel<T extends KubernetesResource>(resource: T, params: BaseNormalizeTypeParams): string;
+    getProject<T extends KubernetesResource>(resource: T): string;
+    private retryUpdate;
+    $get<T extends KubernetesResource>(resource: T, type: string): string;
+    $translate<T extends KubernetesResource>(resource: T, type: string, data?: unknown): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<K8sUtilService<any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<K8sUtilService<any>>;
+}

package/core/services/on-resize.service.d.ts

@@ -0,0 +1,20 @@
+import { AfterViewInit, Injector, NgZone, OnDestroy } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare abstract class ListenResizeDirective implements AfterViewInit, OnDestroy {
+    abstract onResize(): unknown;
+    _resizeService: OnResizeChangeService;
+    constructor(injector: Injector);
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ListenResizeDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ListenResizeDirective, never, never, {}, {}, never, never, false, never>;
+}
+export declare class OnResizeChangeService {
+    private readonly ngZone;
+    private readonly _resizeListeners;
+    constructor(ngZone: NgZone);
+    subscribe(item: ListenResizeDirective): void;
+    unsubscribe(item: ListenResizeDirective): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<OnResizeChangeService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<OnResizeChangeService>;
+}

package/core/services/silently-navigate.service.d.ts

@@ -0,0 +1,11 @@
+import { Location } from '@angular/common';
+import { Router } from '@angular/router';
+import * as i0 from "@angular/core";
+export declare class SilentlyNavigateService {
+    private readonly router;
+    private readonly location;
+    constructor(router: Router, location: Location);
+    navigate(from: string, to: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SilentlyNavigateService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SilentlyNavigateService>;
+}

package/core/services/time.service.d.ts

@@ -0,0 +1,17 @@
+/**
+ * @packageDocumentation
+ * @module utils
+ */
+import { Injector } from '@angular/core';
+import dayjs, { ConfigType } from 'dayjs';
+import * as i0 from "@angular/core";
+export declare class TimeService {
+    private readonly injector;
+    get currTz(): string;
+    constructor(injector: Injector);
+    now(utc?: boolean): dayjs.Dayjs;
+    format(date?: ConfigType, dateFormat?: string): string;
+    distance(date: ConfigType, baseDate?: ConfigType): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TimeService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TimeService>;
+}

package/core/services/ui-state.service.d.ts

@@ -0,0 +1,41 @@
+import { TemplatePortal } from '@angular/cdk/portal';
+import { ReplaySubject } from 'rxjs';
+import { NavItemConfig } from '../../page-scaffold/navigation/nav-menu/nav-menu.types';
+import * as i0 from "@angular/core";
+/**
+ * Provides a holder for UI templates to be used globally.
+ */
+export declare class TemplateHolder {
+    private readonly templatePortalSubject;
+    get templatePortal$(): import("rxjs").Observable<TemplatePortal<any>>;
+    setTemplatePortal(templatePortal: TemplatePortal): void;
+}
+export declare enum TemplateHolderType {
+    PageHeaderContent = "PageHeaderContent"
+}
+export interface ActiveNavItem {
+    label: string;
+    routerLink?: string | any[];
+}
+/**
+ * Acts as a general ui state store
+ */
+export declare class UiStateService {
+    private readonly templateHolders;
+    private _prevViewSwitchState;
+    private _currViewSwitchState;
+    activeItemInfo$: ReplaySubject<NavItemConfig[]>;
+    private registerTemplateHolder;
+    getTemplateHolder(id: TemplateHolderType): TemplateHolder;
+    /**
+     * NOTE: only set active item info in ConsoleComponent
+     */
+    setActiveItemInfo(activeNavItemInfo: NavItemConfig[]): void;
+    /**
+     * NOTE: only use for view switch status recording
+     */
+    setViewSwitchState(state: boolean): void;
+    shouldViewSwitchAnimate(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UiStateService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<UiStateService>;
+}

package/core/services/workspace-helper.service.d.ts

@@ -0,0 +1,12 @@
+import { ActivatedRoute } from '@angular/router';
+import { WorkspaceParams } from '../types';
+import * as i0 from "@angular/core";
+export declare class WorkspaceHelperService {
+    private readonly baseParams$$;
+    baseActivatedRoute: ActivatedRoute;
+    readonly baseParams: import("rxjs").Observable<WorkspaceParams>;
+    get baseParamsSnapshot(): WorkspaceParams;
+    setBaseParams(params: WorkspaceParams): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<WorkspaceHelperService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<WorkspaceHelperService>;
+}

package/core/services/yaml-util.service.d.ts

@@ -0,0 +1,20 @@
+import { Arrayable, KubernetesResource } from '..';
+import * as i0 from "@angular/core";
+export declare class YamlUtilService {
+    private readonly baseDomain;
+    constructor(baseDomain: string);
+    getConciseResource(r: KubernetesResource): KubernetesResource;
+    /**
+     *
+     *
+     * @template T
+     * @param {T} resource
+     * @param {boolean} [concise=false] 精简 Yaml
+     * @param {boolean} [reduce=false] 隐藏 managedFields
+     * @returns
+     * @memberof YamlUtilService
+     */
+    generateFilteredYamlResource<T extends KubernetesResource>(resource: Arrayable<T>, concise?: boolean, reduce?: boolean): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<YamlUtilService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<YamlUtilService>;
+}

package/core/types/commons.d.ts

@@ -0,0 +1,40 @@
+/**
+ * @packageDocumentation
+ * @module types
+ */
+export type StringMap = Record<string, string>;
+export interface Environments {
+    GLOBAL_NAMESPACE?: string;
+    LABEL_BASE_DOMAIN?: string;
+    LOGO_URL?: string;
+    INNER_PROJECT_NS_PREFIX?: string;
+}
+export interface ResourceListParams extends StringMap {
+    limit?: string;
+    continue?: string;
+    labelSelector?: string;
+    fieldSelector?: string;
+    field?: string;
+    keyword?: string;
+}
+export interface WorkspaceParams {
+    project?: string;
+    cluster?: string;
+    namespace?: string;
+    servicemesh?: string;
+}
+export interface WorkspaceListParams extends WorkspaceParams, ResourceListParams {
+}
+export interface WorkspaceDetailParams extends WorkspaceListParams {
+    name?: string;
+}
+export type KeyValue<V = string, T extends object = object> = T & {
+    key: string;
+    value: V;
+};
+export type Pagination<T, O = {
+    [key: string]: unknown;
+}> = {
+    total: number;
+    items: T[];
+} & O;

package/core/types/helpers.d.ts

@@ -0,0 +1,35 @@
+/**
+ * @packageDocumentation
+ * @module types
+ */
+import { Observable } from 'rxjs';
+import { Primitive } from 'ts-essentials';
+export { DeepPartial, DeepReadonly, Dictionary, ValueOf as LooseValueOf, } from 'ts-essentials';
+export type Readonlyable<T> = T | Readonly<T>;
+export type AnyArray<T> = Readonlyable<T[]>;
+export type Arrayable<T, R extends boolean = false> = [R] extends [never] ? T | T[] : R extends true ? Readonly<T> | readonly T[] : R extends false ? Readonlyable<T> | AnyArray<T> : never;
+export type Nullable<T> = T | null | undefined;
+export type Callback<T extends any[] = unknown[], R = unknown> = (...args: T) => R;
+/** Dark magic helper */
+export type IfEqual<X, Y, A = X, B = never> = (<T>() => T extends X ? true : false) extends <T>() => T extends Y ? true : false ? A : B;
+export type Keys<T> = {
+    [Key in keyof T]: Key;
+};
+export type ObservableType<T> = T extends Observable<infer R> ? R : never;
+export type UnaryObservableFunction<T, R> = (source: Observable<T>) => Observable<R>;
+export type ValueOf<T> = T extends {
+    [key: string]: infer M;
+} ? M : T extends {
+    [key: number]: infer N;
+} ? N : never;
+export declare function isErrorMessage<T extends {
+    message: string;
+}>(error: any): error is T;
+export type LiteralUnion<LiteralType, BaseType extends Primitive> = LiteralType | (BaseType & {
+    _?: never;
+});
+export declare const DataSource: {
+    readonly Platform: "Platform";
+    readonly Business: "Business";
+};
+export type DataSource = ValueOf<typeof DataSource>;

package/core/types/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @packageDocumentation
+ * @module types
+ * @preferred
+ */
+export * from './commons';
+export * from './helpers';
+export * from './k8s';
+export * from './schema';
+export * from './resource-definitions';

package/core/types/k8s/core.d.ts

@@ -0,0 +1,91 @@
+import { StringMap } from '@alauda/ui';
+/**
+ * 维护 k8s core 类型，比如 metaType，Condition，ownerRef 等等，
+ * 这里的类型基本是具体类型都依赖的基础类型。大大概率不会变化的
+ */
+export type LimitType = 'Container' | 'Pod' | 'PersistentVolumeClaim';
+export interface LimitRangeSpec extends KubernetesResource {
+    limits: LimitRangeItem[];
+}
+export interface LimitRange extends KubernetesResource {
+    spec?: LimitRangeSpec;
+}
+export interface LimitRangeItem {
+    type: LimitType;
+    min?: StringMap;
+    max?: StringMap;
+    default?: StringMap;
+    defaultRequest?: StringMap;
+    maxLimitRequestRatio?: StringMap;
+}
+export interface ObjectReference {
+    kind?: string;
+    namespace?: string;
+    name?: string;
+    uid?: string;
+    apiVersion?: string;
+    resourceVersion?: string;
+    fieldPath?: string;
+}
+export interface LabelSelector {
+    matchLabels?: StringMap;
+    matchExpressions?: LabelSelectorRequirement[];
+}
+export interface LabelSelectorRequirement {
+    key: string;
+    operator?: // eslint-disable-next-line sonar/max-union-size
+    '=' | '==' | '!=' | '!' | 'in' | 'notin' | 'exists' | 'doesnotexist' | 'In';
+    values?: string[];
+}
+export interface TypeMeta {
+    kind?: string;
+    apiVersion?: string;
+}
+export interface OwnerReference {
+    apiVersion: string;
+    kind: string;
+    name: string;
+    uid: string;
+    controller?: boolean;
+    blockOwnerDeletion?: boolean;
+}
+export interface ObjectMeta {
+    name?: string;
+    generateName?: string;
+    namespace?: string;
+    labels?: StringMap;
+    annotations?: StringMap;
+    finalizers?: string[];
+    selfLink?: string;
+    uid?: string;
+    creationTimestamp?: string;
+    deletionTimestamp?: string;
+    ownerReferences?: OwnerReference[];
+    resourceVersion?: string;
+    generation?: number;
+    continue?: string;
+    totalItems?: number;
+    managedFields?: unknown;
+    clusterName?: string;
+}
+export interface KubernetesResource extends TypeMeta {
+    metadata?: ObjectMeta;
+    spec?: unknown;
+    status?: unknown;
+}
+export interface UntypedKubernetesResource extends TypeMeta {
+    metadata?: ObjectMeta;
+    spec?: any;
+    status?: any;
+}
+export interface KubernetesResourceList<T extends KubernetesResource = KubernetesResource> extends KubernetesResource {
+    items: T[];
+}
+export interface Condition {
+    lastProbeTime?: string;
+    lastTransitionTime?: string;
+    message?: string;
+    reason?: string;
+    status?: string;
+    type?: string;
+}