@alauda-fe/common 1.0.0-hotfix-znx-3.16.1-1

package/grid-layout/utils/react-grid-layout.utils.d.ts

@@ -0,0 +1,171 @@
+export interface LayoutItem {
+    w: number;
+    h: number;
+    x: number;
+    y: number;
+    id: string;
+    minW?: number;
+    minH?: number;
+    maxW?: number;
+    maxH?: number;
+    moved?: boolean;
+    static?: boolean;
+    isDraggable?: boolean | null | undefined;
+    isResizable?: boolean | null | undefined;
+}
+export type Layout = LayoutItem[];
+export interface Position {
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+}
+export interface ReactDraggableCallbackData {
+    node: HTMLElement;
+    x?: number;
+    y?: number;
+    deltaX: number;
+    deltaY: number;
+    lastX?: number;
+    lastY?: number;
+}
+export interface PartialPosition {
+    left: number;
+    top: number;
+}
+export interface DroppingPosition {
+    x: number;
+    y: number;
+    e: Event;
+}
+export interface Size {
+    width: number;
+    height: number;
+}
+export interface GridDragEvent {
+    e: Event;
+    node: HTMLElement;
+    newPosition: PartialPosition;
+}
+export interface GridResizeEvent {
+    e: Event;
+    node: HTMLElement;
+    size: Size;
+}
+export type DragOverEvent = MouseEvent & {
+    nativeEvent: {
+        layerX: number;
+        layerY: number;
+        target: {
+            className: String;
+        };
+    };
+};
+export type EventCallback = (arg0: Layout, oldItem: LayoutItem | null | undefined, newItem: LayoutItem | null | undefined, placeholder: LayoutItem | null | undefined, arg4: Event, arg5: HTMLElement | null | undefined) => void;
+export type CompactType = ('horizontal' | 'vertical') | null | undefined;
+/**
+ * Return the bottom coordinate of the layout.
+ *
+ * @param  {Array} layout Layout array.
+ * @return {Number}       Bottom coordinate.
+ */
+export declare function bottom(layout: Layout): number;
+export declare function cloneLayout(layout: Layout): Layout;
+/** NOTE: This code has been modified from the original source */
+export declare function cloneLayoutItem(layoutItem: LayoutItem): LayoutItem;
+/**
+ * Given two layout items, check if they collide.
+ */
+export declare function collides(l1: LayoutItem, l2: LayoutItem): boolean;
+/**
+ * Given a layout, compact it. This involves going down each y coordinate and removing gaps
+ * between items.
+ *
+ * @param  {Array} layout Layout.
+ * @param  {Boolean} verticalCompact Whether or not to compact the layout
+ *   vertically.
+ * @return {Array}       Compacted Layout.
+ */
+export declare function compact(layout: Layout, compactType: CompactType, cols: number): Layout;
+/**
+ * Compact an item in the layout.
+ */
+export declare function compactItem(compareWith: Layout, l: LayoutItem, compactType: CompactType, cols: number, fullLayout: Layout): LayoutItem;
+/**
+ * Given a layout, make sure all elements fit within its bounds.
+ *
+ * @param  {Array} layout Layout array.
+ * @param  {Number} bounds Number of columns.
+ */
+export declare function correctBounds(layout: Layout, bounds: {
+    cols: number;
+}): Layout;
+/**
+ * Get a layout item by ID. Used so we can override later on if necessary.
+ *
+ * @param  {Array}  layout Layout array.
+ * @param  {String} id     ID
+ * @return {LayoutItem}    Item at ID.
+ */
+export declare function getLayoutItem(layout: Layout, id: string): LayoutItem | null | undefined;
+/**
+ * Returns the first item this layout collides with.
+ * It doesn't appear to matter which order we approach this from, although
+ * perhaps that is the wrong thing to do.
+ *
+ * @param  {Object} layoutItem Layout item.
+ * @return {Object|undefined}  A colliding layout item, or undefined.
+ */
+export declare function getFirstCollision(layout: Layout, layoutItem: LayoutItem): LayoutItem | null | undefined;
+export declare function getAllCollisions(layout: Layout, layoutItem: LayoutItem): LayoutItem[];
+/**
+ * Get all static elements.
+ * @param  {Array} layout Array of layout objects.
+ * @return {Array}        Array of static layout items..
+ */
+export declare function getStatics(layout: Layout): LayoutItem[];
+/**
+ * Move an element. Responsible for doing cascading movements of other elements.
+ *
+ * @param  {Array}      layout            Full layout to modify.
+ * @param  {LayoutItem} l                 element to move.
+ * @param  {Number}     [x]               X position in grid units.
+ * @param  {Number}     [y]               Y position in grid units.
+ */
+export declare function moveElement(layout: Layout, l: LayoutItem, x: number | null | undefined, y: number | null | undefined, isUserAction: boolean | null | undefined, preventCollision: boolean | null | undefined, compactType: CompactType, cols: number): Layout;
+/**
+ * This is where the magic needs to happen - given a collision, move an element away from the collision.
+ * We attempt to move it up if there's room, otherwise it goes below.
+ *
+ * @param  {Array} layout            Full layout to modify.
+ * @param  {LayoutItem} collidesWith Layout item we're colliding with.
+ * @param  {LayoutItem} itemToMove   Layout item we're moving.
+ */
+export declare function moveElementAwayFromCollision(layout: Layout, collidesWith: LayoutItem, itemToMove: LayoutItem, isUserAction: boolean | null | undefined, compactType: CompactType, cols: number): Layout;
+/**
+ * Helper to convert a number to a percentage string.
+ *
+ * @param  {Number} num Any number
+ * @return {String}     That number as a percentage.
+ */
+export declare function percent(num: number): string;
+export declare function setTransform({ top, left, width, height }: Position): Object;
+export declare function setTopLeft({ top, left, width, height }: Position): Object;
+/**
+ * Get layout items sorted from top left to right and down.
+ *
+ * @return {Array} Array of layout objects.
+ * @return {Array}        Layout, sorted static items first.
+ */
+export declare function sortLayoutItems(layout: Layout, compactType: CompactType): Layout;
+export declare function sortLayoutItemsByRowCol(layout: Layout): Layout;
+export declare function sortLayoutItemsByColRow(layout: Layout): Layout;
+/**
+ * Validate a layout. Throws errors.
+ *
+ * @param  {Array}  layout        Array of layout items.
+ * @param  {String} [contextName] Context name for errors.
+ * @throw  {Error}                Validation error.
+ */
+export declare function validateLayout(layout: Layout, contextName?: string): void;
+export declare function autoBindHandlers(el: Object, fns: string[]): void;

package/grid-layout/utils/scroll.utils.d.ts

@@ -0,0 +1,28 @@
+import { Observable } from 'rxjs';
+export interface KtdScrollPosition {
+    top: number;
+    left: number;
+}
+export interface ScrollIfNearElementOptions {
+    scrollStep?: number;
+    disableVertical?: boolean;
+    disableHorizontal?: boolean;
+}
+/**
+ * Given a source$ observable with pointer location, scroll the scrollNode if the pointer is near to it.
+ * This observable doesn't emit, it just performs a 'scroll' side effect.
+ * @param scrollableParent, parent node in which the scroll would be performed.
+ * @param options, configuration options.
+ */
+export declare function scrollIfNearElementClientRect$(scrollableParent: Element | Document, options?: ScrollIfNearElementOptions): (source$: Observable<{
+    pointerX: number;
+    pointerY: number;
+}>) => Observable<any>;
+/**
+ * Emits on EVERY scroll event and returns the accumulated scroll offset relative to the initial scroll position.
+ * @param scrollableParent, node in which scroll events would be listened.
+ */
+export declare function getScrollTotalRelativeDifference$(scrollableParent: Element | Document): Observable<{
+    top: number;
+    left: number;
+}>;

package/help-document/component.d.ts

@@ -0,0 +1,29 @@
+import { ChangeDetectorRef, ElementRef, EventEmitter, InjectionToken, OnDestroy } from '@angular/core';
+import { DomSanitizer } from '@angular/platform-browser';
+import { Subject } from 'rxjs';
+import { ResizeEvent } from '../core/public-api';
+import * as i0 from "@angular/core";
+export declare const TOKEN_HELP_DOC_DATA: InjectionToken<unknown>;
+export declare class HelpDocumentComponent implements OnDestroy {
+    data: {
+        rawUrl: string;
+        title: string;
+    };
+    readonly cdr: ChangeDetectorRef;
+    readonly sanitizer: DomSanitizer;
+    frame: ElementRef<HTMLFrameElement>;
+    overlay: boolean;
+    currentHref: string;
+    small: boolean;
+    destroy$$: Subject<void>;
+    close: EventEmitter<void>;
+    constructor(data: {
+        rawUrl: string;
+        title: string;
+    }, cdr: ChangeDetectorRef, sanitizer: DomSanitizer);
+    onResized({ width }: ResizeEvent): void;
+    back(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HelpDocumentComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HelpDocumentComponent, "ng-component", never, {}, {}, never, never, false, never>;
+}

package/help-document/directive.d.ts

@@ -0,0 +1,47 @@
+import { ChangeDetectorRef, ElementRef, OnDestroy } from '@angular/core';
+import { DomSanitizer, SafeUrl } from '@angular/platform-browser';
+import { Observable } from 'rxjs';
+import { TranslateService } from '../translate/translate.service';
+import { HelpDocumentService } from './service';
+import * as i0 from "@angular/core";
+export declare enum PRODUCT_BASE_HREF_MAP {
+    devops = "/console-devops-docs/",
+    acp = "/console-acp-docs/",
+    asm = "/console-asm-docs/",
+    dataservices = "/console-dataservices-docs/",
+    cec = "/console-cec-docs/",
+    platform = "/console-platform-docs/",
+    portal = "/console-portal-docs/"
+}
+export interface DocsOption {
+    type?: 'popover' | 'page';
+    title?: string;
+    product?: keyof typeof PRODUCT_BASE_HREF_MAP;
+    path?: string;
+    rawUrl?: string;
+}
+export declare class DocsDirective implements OnDestroy {
+    private readonly el;
+    private readonly helpDocService;
+    private readonly translate;
+    private readonly sanitizer;
+    private readonly cdr;
+    docsOption: DocsOption | string;
+    docsOption$: Observable<DocsOption | string>;
+    openDocs(): boolean;
+    set href(val: string | SafeUrl);
+    get href(): string | SafeUrl;
+    get target(): "" | "_blank";
+    get option(): DocsOption;
+    get isInvalidHref(): boolean;
+    defaultOption: DocsOption;
+    hostElTag: string;
+    _href: string | SafeUrl;
+    private readonly destroy$$;
+    constructor(el: ElementRef, helpDocService: HelpDocumentService, translate: TranslateService, sanitizer: DomSanitizer, cdr: ChangeDetectorRef);
+    ngOnDestroy(): void;
+    updateHref(): void;
+    private getUrl;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DocsDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DocsDirective, "[aclDocs]", never, { "docsOption": { "alias": "aclDocs"; "required": false; }; "href": { "alias": "href"; "required": false; }; }, {}, never, never, false, never>;
+}

package/help-document/module.d.ts

@@ -0,0 +1,13 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./component";
+import * as i2 from "./directive";
+import * as i3 from "@angular/common";
+import * as i4 from "@alauda/ui";
+import * as i5 from "../translate/translate.module";
+import * as i6 from "../core/module";
+import * as i7 from "../mutable/mutable.module";
+export declare class HelpDocumentModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<HelpDocumentModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<HelpDocumentModule, [typeof i1.HelpDocumentComponent, typeof i2.DocsDirective], [typeof i3.CommonModule, typeof i4.IconModule, typeof i5.TranslateModule, typeof i6.CoreModule, typeof i7.MutableModule], [typeof i1.HelpDocumentComponent, typeof i2.DocsDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<HelpDocumentModule>;
+}

package/help-document/public-api.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @packageDocumentation
+ * @module help-document
+ * @preferred
+ */
+export * from './component';
+export * from './service';
+export * from './module';
+export * from './directive';

package/help-document/service.d.ts

@@ -0,0 +1,30 @@
+import { ComponentPortal, DomPortalOutlet } from '@angular/cdk/portal';
+import { ApplicationRef, ComponentFactoryResolver, Injector } from '@angular/core';
+import { Subscription } from 'rxjs';
+import { TranslateService } from '../translate/translate.service';
+import { HelpDocumentComponent } from './component';
+import * as i0 from "@angular/core";
+interface DocsLinkTypeParams {
+    url: string;
+    customHref: string;
+}
+export declare class HelpDocumentService {
+    private readonly docsBaseHref;
+    private readonly translate;
+    private readonly rootInjector;
+    private readonly cfr;
+    private readonly appRef;
+    constructor(docsBaseHref: string, translate: TranslateService, rootInjector: Injector, cfr: ComponentFactoryResolver, appRef: ApplicationRef);
+    portalHost: DomPortalOutlet;
+    subscription: Subscription;
+    portal: ComponentPortal<HelpDocumentComponent>;
+    open(context?: {
+        title: string;
+        rawUrl: string;
+    }): void;
+    getMultilingualDocsPath(urlOrParams: string | DocsLinkTypeParams): string;
+    private getPath;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HelpDocumentService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<HelpDocumentService>;
+}
+export {};

package/iframe-config/config.service.d.ts

@@ -0,0 +1,20 @@
+import { COLLAPSE_MENU_KEY, HIDE_HEADER_KEY, HIDE_MENU_KEY } from './constants';
+import * as i0 from "@angular/core";
+declare class IframeConfig {
+    [HIDE_MENU_KEY]?: string;
+    [HIDE_HEADER_KEY]?: string;
+    [COLLAPSE_MENU_KEY]?: string;
+}
+export declare class IframeConfigService {
+    private readonly iframeConfig$$;
+    get iframeConfig(): IframeConfig;
+    get isHideHeader(): boolean;
+    get isCollapseMenu(): boolean;
+    get isHideMenu(): boolean;
+    constructor();
+    private setIframeBasePageConfig;
+    private getParams;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IframeConfigService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<IframeConfigService>;
+}
+export {};

package/iframe-config/constants.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @packageDocumentation
+ * @module iframeConfig
+ */
+export declare const HIDE_MENU_KEY = "hide_menu";
+export declare const HIDE_HEADER_KEY = "hide_header";
+export declare const COLLAPSE_MENU_KEY = "collapse_menu";

package/iframe-config/public-api.d.ts

@@ -0,0 +1,8 @@
+/**
+ * [[include:utils/README.md]]
+ * @module iframeConfig
+ * @preferred
+ */
+/** imports */
+export * from './constants';
+export * from './config.service';

package/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+/// <amd-module name="@alauda-fe/common" />
+export * from './public-api';

package/k8s-resource-list/footer/component.d.ts

@@ -0,0 +1,37 @@
+/**
+ * @packageDocumentation
+ * @module k8s-resource-list
+ */
+import { OnDestroy, OnInit, TemplateRef, Injector } from '@angular/core';
+import { Observable } from 'rxjs';
+import { KubernetesResource, KubernetesResourceList, ScrollBorderObserverDirective } from '../../core/public-api';
+import { TranslateService } from '../../translate/public-api';
+import { StreamListLoader } from '../types';
+import * as i0 from "@angular/core";
+export declare class K8sListFooterNoDataDirective {
+    templateRef: TemplateRef<any>;
+    constructor(templateRef: TemplateRef<any>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<K8sListFooterNoDataDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<K8sListFooterNoDataDirective, "[aclK8sListFooterNoData]", never, {}, {}, never, never, false, never>;
+}
+export declare class K8SResourceListFooterComponent extends ScrollBorderObserverDirective implements OnInit, OnDestroy {
+    private readonly translate;
+    list: StreamListLoader<KubernetesResourceList, KubernetesResource>;
+    autoLoad: boolean;
+    backTop: boolean;
+    bottomDistance: number;
+    resourceNameTranslated: string;
+    resourceNameTranslated$: Observable<string>;
+    resourceName: string;
+    resourceName$: Observable<string>;
+    noDataTemplate: TemplateRef<any>;
+    isEmptyList$: Observable<boolean>;
+    noDataHint$: Observable<string>;
+    loadingErrorCode$: Observable<number>;
+    window: Window & typeof globalThis;
+    constructor(injector: Injector, translate: TranslateService);
+    ngOnInit(): void;
+    retry(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<K8SResourceListFooterComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<K8SResourceListFooterComponent, "acl-k8s-resource-list-footer", never, { "list": { "alias": "list"; "required": false; }; "autoLoad": { "alias": "autoLoad"; "required": false; }; "backTop": { "alias": "backTop"; "required": false; }; "bottomDistance": { "alias": "bottomDistance"; "required": false; }; "resourceNameTranslated": { "alias": "resourceNameTranslated"; "required": false; }; "resourceName": { "alias": "resourceName"; "required": false; }; }, {}, ["noDataTemplate"], never, false, never>;
+}

package/k8s-resource-list/k8s-resource-list.d.ts

@@ -0,0 +1,42 @@
+/**
+ * @packageDocumentation
+ * @module k8s-resource-list
+ */
+import { HttpErrorResponse } from '@angular/common/http';
+import { Observable, ReplaySubject } from 'rxjs';
+import { KubernetesResource, KubernetesResourceList, ResourceListParams, Status } from '../core/public-api';
+import { ConfigWithParams, ConfigWithRoute, ItemsScanner, ListParams, LoadSnapshot, LoadState, StreamListLoader } from './types';
+export declare class K8SResourceList<R extends KubernetesResource = KubernetesResource, Q extends object = ResourceListParams, P extends Q & ListParams = Q & ListParams> implements StreamListLoader<KubernetesResourceList<R>, R> {
+    private readonly reloadAction$$;
+    private readonly loadMoreAction$$;
+    private readonly itemsScanner$$;
+    private readonly destroy$$;
+    private readonly insertFn;
+    loadState$: Observable<LoadState<KubernetesResourceList<R>>>;
+    queryParams$: Observable<Q>;
+    rawResponse$: Observable<KubernetesResourceList<R>>;
+    loading$: Observable<boolean>;
+    loadingError$: Observable<HttpErrorResponse | Status>;
+    hasMore$: Observable<boolean>;
+    continueToken$: Observable<string>;
+    items$: Observable<R[]>;
+    bypassItems$: ReplaySubject<R[]>;
+    timer: number;
+    snapshot: LoadSnapshot<KubernetesResourceList<R>, R, Q>;
+    constructor({ fetcher, activatedRoute }: ConfigWithRoute<R, Q, P>);
+    constructor({ fetcher, fetchParams$ }: ConfigWithParams<R, Q, P>);
+    reload(silent?: boolean): void;
+    loadMore(): void;
+    scanItems(scanner: ItemsScanner<R>): void;
+    destroy(): void;
+    create(resource: R): void;
+    update(resource: R): void;
+    delete(resource?: R): void;
+    private _create;
+    private _update;
+    private _delete;
+    private buildLoadStateStream;
+    private extractContinueTokenFromState;
+    private initStreams;
+    private buildWatcher;
+}

package/k8s-resource-list/k8s-resource-list.module.d.ts

@@ -0,0 +1,10 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./footer/component";
+import * as i2 from "@angular/common";
+import * as i3 from "@alauda/ui";
+import * as i4 from "../translate/translate.module";
+export declare class K8SResourceListModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<K8SResourceListModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<K8SResourceListModule, [typeof i1.K8SResourceListFooterComponent, typeof i1.K8sListFooterNoDataDirective], [typeof i2.CommonModule, typeof i3.ButtonModule, typeof i3.IconModule, typeof i3.BackTopModule, typeof i4.TranslateModule], [typeof i1.K8SResourceListFooterComponent, typeof i1.K8sListFooterNoDataDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<K8SResourceListModule>;
+}

package/k8s-resource-list/k8s-resource-paged-list.d.ts

@@ -0,0 +1,61 @@
+import { HttpErrorResponse } from '@angular/common/http';
+import { Signal } from '@angular/core';
+import { Params } from '@angular/router';
+import { Observable } from 'rxjs';
+import { WatchAPIResponse } from '../api/public-api';
+import { KubernetesResource, KubernetesResourceList, Status } from '../core/public-api';
+export declare class K8SResourcePagedList<R extends KubernetesResource = KubernetesResource, P = unknown> {
+    private readonly config;
+    private readonly reload$$;
+    private readonly addedUid;
+    private readonly deletedUid;
+    params$: Observable<ListFetchParams<P>>;
+    loadState$: Observable<LoadState<R>>;
+    loading$: Observable<boolean>;
+    items$: Observable<R[]>;
+    totalItems$: Observable<number>;
+    loadError$: Observable<Status | HttpErrorResponse>;
+    $loading: Signal<boolean>;
+    $items: Signal<R[]>;
+    $totalItems: Signal<number>;
+    $loadError: Signal<Status | HttpErrorResponse>;
+    constructor(config: PagedListConfig<R, P>);
+    reload(): void;
+    private sourceLoadState;
+    private loadStateWithPolling;
+    private loadStateWithWatcher;
+}
+export interface PagedListConfig<R, P> {
+    params: Signal<ListFetchParams<P>> | Observable<ListFetchParams<P>>;
+    fetcher: (listParams: FetchSeed, extraParams: P) => Observable<KubernetesResourceList<R>>;
+    watcher?: (listParams: FetchSeed, extraParams: P) => Observable<WatchAPIResponse<R>>;
+    polling?: number;
+}
+export interface ListFetchParams<P = never> {
+    pageIndex?: number | string;
+    pageSize?: number | string;
+    sortField?: string;
+    sortOrder?: 'asc' | 'desc';
+    keyword?: string;
+    fieldSelector?: string;
+    labelSelector?: string;
+    extra?: P;
+}
+export interface FetchSeed extends Record<string, string> {
+    limit?: string;
+    continue?: string;
+    fieldSelector?: string;
+}
+interface LoadState<R> {
+    items: R[];
+    totalItems: number;
+    loading: boolean;
+    loadSuccess: boolean;
+    loadError?: HttpErrorResponse | Status;
+}
+export declare function extractPagedListParams<P>(defaultParams?: ListFetchParams, extraParams?: (queryParams: Params) => P): Readonly<{
+    stream: () => Observable<ListFetchParams<P>>;
+    signal: () => Signal<ListFetchParams<P>>;
+}>;
+export declare function queryListParams(): (queryParams: Params) => void;
+export {};

package/k8s-resource-list/public-api.d.ts

@@ -0,0 +1,12 @@
+/**
+ * [[include:k8s-resource-list/README.md]]
+ * @module k8s-resource-list
+ * @preferred
+ */
+/** imports */
+export * from './footer/component';
+export * from './k8s-resource-list';
+export * from './k8s-resource-list.module';
+export * from './types';
+export * from './utils';
+export * from './k8s-resource-paged-list';

package/k8s-resource-list/types.d.ts

@@ -0,0 +1,70 @@
+/**
+ * @packageDocumentation
+ * @module k8s-resource-list
+ */
+import { HttpErrorResponse } from '@angular/common/http';
+import { ActivatedRoute } from '@angular/router';
+import { Observable } from 'rxjs';
+import { WatchAPIResponse } from '../api/types';
+import { StringMap, KubernetesResource, KubernetesResourceList, Status } from '../core/public-api';
+import { K8SResourceList } from './k8s-resource-list';
+export type Watcher<R extends KubernetesResource, Q> = (seedVersion: string, params?: Q) => Observable<WatchAPIResponse<R>>;
+export type InsertFn<R> = (items: R[], res: R, hasMore: boolean) => R[];
+export interface WatcherParams<R extends KubernetesResource, Q> {
+    list: K8SResourceList<R>;
+    watcher: Watcher<R, Q>;
+    insertFn?: InsertFn<R>;
+}
+interface BaseConfig<R extends KubernetesResource, Q> {
+    watcher?: Watcher<R, Q>;
+    insertFn?: InsertFn<R>;
+    limit?: number;
+    polling?: number;
+}
+export type ItemsScanner<R> = (items: R[]) => R[];
+export interface ConfigWithRoute<R, Q, P> extends BaseConfig<R, Q> {
+    fetcher: (params: P) => Observable<KubernetesResourceList<R>>;
+    activatedRoute?: ActivatedRoute;
+}
+export interface ConfigWithParams<R, Q, P> extends BaseConfig<R, Q> {
+    fetcher: (params: P) => Observable<KubernetesResourceList<R>>;
+    fetchParams$?: Observable<Q>;
+}
+export declare enum LoadAction {
+    Reload = "Reload",
+    SilentReload = "SilentReload",
+    LoadMore = "LoadMore"
+}
+export interface LoadState<R> {
+    action?: LoadAction;
+    rawResponse?: R;
+    loading?: boolean;
+    loadingError?: HttpErrorResponse | Status;
+}
+export interface ListParams extends StringMap {
+    limit: string;
+    continue: string;
+}
+export interface StreamListLoader<R, T> {
+    loadState$: Observable<LoadState<R>>;
+    loading$: Observable<boolean>;
+    loadingError$: Observable<HttpErrorResponse | Status>;
+    hasMore$: Observable<boolean>;
+    rawResponse$: Observable<R>;
+    items$: Observable<T[]>;
+    snapshot: StreamListLoaderSnapshot<R, T>;
+    loadMore(): void;
+    reload(): void;
+}
+export interface StreamListLoaderSnapshot<R, T> {
+    rawResponse?: R;
+    loading?: boolean;
+    loadingError?: HttpErrorResponse | Status;
+    hasMore?: boolean;
+    continueToken?: string;
+    items?: T[];
+}
+export interface LoadSnapshot<R, T, Q> extends StreamListLoaderSnapshot<R, T> {
+    queryParams?: Q;
+}
+export {};

package/k8s-resource-list/utils.d.ts

@@ -0,0 +1,19 @@
+/**
+ * @packageDocumentation
+ * @module k8s-resource-list
+ */
+import { ActivatedRoute } from '@angular/router';
+import { Observable } from 'rxjs';
+import { ResourceListParams, StringMap, LabelSelectorRequirement } from '../core/public-api';
+/**
+ * convert selector.matchLabels to string
+ * refers to: https://kubernetes.io/docs/concepts/overview/working-with-objects/labels/#api
+ */
+export declare function matchLabelsToString(params?: StringMap): string;
+/**
+ * convert string to selector.matchLabels
+ */
+export declare function stringToMatchLabels(str?: string): Record<string, string>;
+export declare function matchExpressionsToString(params: LabelSelectorRequirement[]): string;
+export declare function extractListParamsFromRoute(route: ActivatedRoute): Observable<ResourceListParams>;
+export declare function normalizeParams<P extends object>(params: P): P;