@alauda-fe/common 1.0.0-next.0

package/esm2022/k8s-resource-list/k8s-resource-list.mjs

@@ -0,0 +1,226 @@
+/**
+ * @packageDocumentation
+ * @module k8s-resource-list
+ */
+import { EMPTY, Subject, merge, of, catchError, distinctUntilChanged, exhaustMap, filter, map, scan, startWith, switchMap, takeUntil, tap, finalize, ReplaySubject, } from 'rxjs';
+import { WatchEvent } from '../api/types';
+import { DOWNGRADE_WATCH_ENABLED, publishRef, } from '../core';
+import { LoadAction, } from './types';
+import { extractListParamsFromRoute, normalizeParams } from './utils';
+export class K8SResourceList {
+    constructor({ fetcher, fetchParams$, activatedRoute, limit = 20, polling = 0, watcher, insertFn = defaultInsert, }) {
+        this.reloadAction$$ = new Subject();
+        this.loadMoreAction$$ = new Subject();
+        this.itemsScanner$$ = new Subject();
+        this.destroy$$ = new Subject();
+        this.bypassItems$ = new ReplaySubject(1);
+        this.snapshot = {};
+        this.insertFn = insertFn;
+        this.queryParams$ = (fetchParams$ ||
+            (activatedRoute
+                ? extractListParamsFromRoute(activatedRoute)
+                : of(null))).pipe(publishRef());
+        const validPolling = (polling && watcher && DOWNGRADE_WATCH_ENABLED) || (polling && !watcher)
+            ? polling
+            : 0;
+        this.loadState$ = this.buildLoadStateStream({
+            queryParams$: this.queryParams$,
+            fetcher,
+            limit,
+            polling: validPolling,
+        });
+        this.insertFn = insertFn;
+        this.initStreams(validPolling ? null : watcher);
+    }
+    reload(silent = false) {
+        this.reloadAction$$.next(silent);
+    }
+    loadMore() {
+        this.loadMoreAction$$.next();
+    }
+    scanItems(scanner) {
+        this.itemsScanner$$.next(scanner);
+    }
+    destroy() {
+        this.destroy$$.next();
+        this.destroy$$.complete();
+    }
+    create(resource) {
+        this.scanItems(this._create(resource));
+    }
+    update(resource) {
+        this.scanItems(this._update(resource));
+    }
+    delete(resource) {
+        if (!resource) {
+            return;
+        }
+        this.scanItems(this._delete(resource));
+    }
+    _create(resource) {
+        return (items) => {
+            if (!resource.metadata.name
+                .toLowerCase()
+                .includes(this.snapshot.queryParams?.keyword?.toLowerCase() ??
+                '')) {
+                return items;
+            }
+            return this.insertFn(items, resource, this.snapshot.hasMore);
+        };
+    }
+    _update(resource) {
+        return (items) => items.map(item => item.metadata.uid === resource.metadata.uid ? resource : item);
+    }
+    _delete({ metadata: { uid } }) {
+        return (items) => items.filter(item => item.metadata.uid !== uid);
+    }
+    buildLoadStateStream({ queryParams$, fetcher, polling, limit, }) {
+        const load$ = merge(queryParams$.pipe(map(queryParams => () => ({ queryParams, action: LoadAction.Reload }))), this.reloadAction$$.pipe(map(silent => (prev) => ({
+            ...prev,
+            action: silent ? LoadAction.SilentReload : LoadAction.Reload,
+        })))).pipe(scan((acc, scanner) => scanner(acc), {}), tap(({ action, queryParams }) => {
+            if (action === LoadAction.Reload) {
+                this.snapshot = {
+                    queryParams,
+                };
+                this.bypassItems$.next(null);
+            }
+        }));
+        return load$.pipe(
+        // eslint-disable-next-line sonarjs/cognitive-complexity
+        switchMap(({ action: leadAction, queryParams }) => this.loadMoreAction$$.pipe(filter(() => this.snapshot.hasMore), map(() => true), startWith(false), exhaustMap(loadMore => {
+            if (this.timer) {
+                window.clearTimeout(this.timer);
+            }
+            const token = this.snapshot.continueToken;
+            const hasMore = this.snapshot.hasMore;
+            const currLength = this.snapshot.items?.length ?? limit;
+            const action = loadMore ? LoadAction.LoadMore : leadAction;
+            return fetcher(normalizeParams({
+                limit: `${action === LoadAction.SilentReload
+                    ? hasMore
+                        ? currLength
+                        : 0
+                    : limit}`,
+                continue: action === LoadAction.LoadMore ? token : '',
+                ...queryParams,
+            })).pipe(map(rawResponse => ({ rawResponse, loadingError: null })), catchError((err) => of({
+                loadingError: action === LoadAction.SilentReload ? null : err,
+            })), tap(res => {
+                if (polling && !res.loadingError) {
+                    this.timer = window.setTimeout(() => {
+                        this.reload(true);
+                    }, polling);
+                }
+            }), map(state => ({
+                ...state,
+                action,
+            })), startWith({
+                action,
+                loading: true,
+            }));
+        }))), map(state => ({
+            action: LoadAction.LoadMore,
+            rawResponse: null,
+            loading: false,
+            loadingError: null,
+            ...state,
+        })), tap(state => {
+            this.snapshot.rawResponse = state.rawResponse;
+            this.snapshot.loadingError = state.loadingError;
+            this.snapshot.loading =
+                state.loading && state.action !== LoadAction.SilentReload;
+            this.snapshot.continueToken = this.extractContinueTokenFromState(state);
+            this.snapshot.hasMore = !!this.snapshot.continueToken;
+        }), finalize(() => {
+            this.snapshot = {};
+            this.bypassItems$.next(null);
+            if (this.timer) {
+                window.clearTimeout(this.timer);
+            }
+        }), takeUntil(this.destroy$$), publishRef());
+    }
+    extractContinueTokenFromState({ rawResponse, loadingError, }) {
+        if (rawResponse) {
+            return rawResponse.metadata?.continue ?? '';
+        }
+        if (loadingError && 'code' in loadingError && loadingError.code === 410) {
+            return loadingError.metadata?.continue;
+        }
+        return this.snapshot.continueToken;
+    }
+    // eslint-disable-next-line sonarjs/cognitive-complexity
+    initStreams(watcher) {
+        this.rawResponse$ = this.loadState$.pipe(map(data => data.rawResponse), distinctUntilChanged(), publishRef());
+        this.loading$ = this.loadState$.pipe(map(({ loading, action }) => loading && action !== LoadAction.SilentReload), distinctUntilChanged(), publishRef());
+        this.loadingError$ = this.loadState$.pipe(map(state => state.loadingError), distinctUntilChanged(), publishRef());
+        this.continueToken$ = this.loadState$.pipe(filter(({ loading }) => !loading), switchMap(({ rawResponse, loadingError: err }) => {
+            if (rawResponse) {
+                return of(rawResponse.metadata?.continue ?? '');
+            }
+            if (err && 'code' in err && err.code === 410) {
+                return of(err.metadata?.continue);
+            }
+            return EMPTY;
+        }), distinctUntilChanged(), publishRef());
+        this.hasMore$ = this.continueToken$.pipe(map(token => !!token), distinctUntilChanged(), publishRef());
+        this.items$ = merge(this.loadState$.pipe(map(state => (items) => {
+            const newItems = state.rawResponse
+                ? state.rawResponse.items ?? []
+                : null;
+            if (state.action === LoadAction.Reload) {
+                return newItems ?? [];
+            }
+            if (state.action === LoadAction.SilentReload) {
+                return newItems ?? items;
+            }
+            if (state.action === LoadAction.LoadMore) {
+                return newItems ? [...items, ...newItems] : items;
+            }
+            return items;
+        })), this.itemsScanner$$, watcher ? this.buildWatcher(watcher) : EMPTY).pipe(scan((acc, scanner) => scanner(acc), []), tap(items => {
+            this.snapshot.items = items;
+            this.bypassItems$.next(items);
+        }), takeUntil(this.destroy$$), publishRef());
+    }
+    buildWatcher(watcher) {
+        return this.rawResponse$.pipe(filter(res => !!res), distinctUntilChanged((a, b) => a.metadata?.resourceVersion === b.metadata?.resourceVersion), switchMap(list => watcher(list.metadata?.resourceVersion, this.snapshot.queryParams).pipe(catchError(() => {
+            this.reload(true);
+            return EMPTY;
+        }))), switchMap(({ type, object: resource }) => {
+            switch (type) {
+                case WatchEvent.Added: {
+                    return of(this._create(resource));
+                }
+                case WatchEvent.Modified: {
+                    return of(this._update(resource));
+                }
+                case WatchEvent.Deleted: {
+                    return of(this._delete(resource));
+                }
+                default: {
+                    return EMPTY;
+                }
+            }
+        }));
+    }
+}
+function defaultInsert(items, res, hasMore) {
+    for (let i = 0; i < items.length; i++) {
+        const compare = resourceCompare(res, items[i]);
+        if (compare === 0) {
+            return items.map((item, index) => (index === i ? res : item));
+        }
+        if (compare < 0) {
+            return [...items.slice(0, i), res, ...items.slice(i)];
+        }
+    }
+    return hasMore ? items : [...items, res];
+}
+function resourceCompare(a, b) {
+    const nsCompare = a.metadata.namespace?.localeCompare(b.metadata.namespace) ?? 0;
+    return nsCompare === 0
+        ? a.metadata.name.localeCompare(b.metadata.name)
+        : nsCompare;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"k8s-resource-list.js","sourceRoot":"","sources":["../../../../../libs/common/src/k8s-resource-list/k8s-resource-list.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @packageDocumentation\n * @module k8s-resource-list\n */\n\nimport { HttpErrorResponse } from '@angular/common/http';\nimport {\n  EMPTY,\n  Observable,\n  Subject,\n  merge,\n  of,\n  catchError,\n  distinctUntilChanged,\n  exhaustMap,\n  filter,\n  map,\n  scan,\n  startWith,\n  switchMap,\n  takeUntil,\n  tap,\n  finalize,\n  ReplaySubject,\n} from 'rxjs';\n\nimport { WatchEvent } from '../api/types';\nimport {\n  KubernetesResource,\n  KubernetesResourceList,\n  ResourceListParams,\n  Status,\n  DOWNGRADE_WATCH_ENABLED,\n  publishRef,\n  StringMap,\n} from '../core';\n\nimport {\n  ConfigWithParams,\n  ConfigWithRoute,\n  InsertFn,\n  ItemsScanner,\n  ListParams,\n  LoadAction,\n  LoadSnapshot,\n  LoadState,\n  StreamListLoader,\n  Watcher,\n} from './types';\nimport { extractListParamsFromRoute, normalizeParams } from './utils';\n\nexport class K8SResourceList<\n  R extends KubernetesResource = KubernetesResource,\n  Q extends object = ResourceListParams,\n  P extends Q & ListParams = Q & ListParams,\n> implements StreamListLoader<KubernetesResourceList<R>, R>\n{\n  private readonly reloadAction$$ = new Subject<boolean>();\n  private readonly loadMoreAction$$ = new Subject<void>();\n  private readonly itemsScanner$$ = new Subject<ItemsScanner<R>>();\n  private readonly destroy$$ = new Subject<void>();\n  private readonly insertFn: InsertFn<R>;\n\n  loadState$: Observable<LoadState<KubernetesResourceList<R>>>;\n\n  queryParams$: Observable<Q>;\n  rawResponse$: Observable<KubernetesResourceList<R>>;\n  loading$: Observable<boolean>;\n  loadingError$: Observable<HttpErrorResponse | Status>;\n  hasMore$: Observable<boolean>;\n  continueToken$: Observable<string>;\n  items$: Observable<R[]>;\n  bypassItems$ = new ReplaySubject<R[]>(1);\n\n  timer: number;\n\n  snapshot: LoadSnapshot<KubernetesResourceList<R>, R, Q> = {};\n\n  constructor({ fetcher, activatedRoute }: ConfigWithRoute<R, Q, P>);\n  // eslint-disable-next-line @typescript-eslint/unified-signatures\n  constructor({ fetcher, fetchParams$ }: ConfigWithParams<R, Q, P>);\n  constructor({\n    fetcher,\n    fetchParams$,\n    activatedRoute,\n    limit = 20,\n    polling = 0,\n    watcher,\n    insertFn = defaultInsert,\n  }: ConfigWithRoute<R, Q, P> & ConfigWithParams<R, Q, P>) {\n    this.insertFn = insertFn;\n\n    this.queryParams$ = (\n      (fetchParams$ ||\n        (activatedRoute\n          ? extractListParamsFromRoute(activatedRoute)\n          : of(null))) as Observable<Q>\n    ).pipe(publishRef());\n\n    const validPolling =\n      (polling && watcher && DOWNGRADE_WATCH_ENABLED) || (polling && !watcher)\n        ? polling\n        : 0;\n\n    this.loadState$ = this.buildLoadStateStream({\n      queryParams$: this.queryParams$,\n      fetcher,\n      limit,\n      polling: validPolling,\n    });\n\n    this.insertFn = insertFn;\n\n    this.initStreams(validPolling ? null : watcher);\n  }\n\n  reload(silent = false) {\n    this.reloadAction$$.next(silent);\n  }\n\n  loadMore() {\n    this.loadMoreAction$$.next();\n  }\n\n  scanItems(scanner: ItemsScanner<R>) {\n    this.itemsScanner$$.next(scanner);\n  }\n\n  destroy() {\n    this.destroy$$.next();\n    this.destroy$$.complete();\n  }\n\n  create(resource: R) {\n    this.scanItems(this._create(resource));\n  }\n\n  update(resource: R) {\n    this.scanItems(this._update(resource));\n  }\n\n  delete(resource?: R) {\n    if (!resource) {\n      return;\n    }\n    this.scanItems(this._delete(resource));\n  }\n\n  private _create(resource: R) {\n    return (items: R[]) => {\n      if (\n        !resource.metadata.name\n          .toLowerCase()\n          .includes(\n            (this.snapshot.queryParams as StringMap)?.keyword?.toLowerCase() ??\n              '',\n          )\n      ) {\n        return items;\n      }\n      return this.insertFn(items, resource, this.snapshot.hasMore);\n    };\n  }\n\n  private _update(resource: R) {\n    return (items: R[]) =>\n      items.map(item =>\n        item.metadata.uid === resource.metadata.uid ? resource : item,\n      );\n  }\n\n  private _delete({ metadata: { uid } }: R) {\n    return (items: R[]) => items.filter(item => item.metadata.uid !== uid);\n  }\n\n  private buildLoadStateStream({\n    queryParams$,\n    fetcher,\n    polling,\n    limit,\n  }: {\n    queryParams$: Observable<Q>;\n    fetcher: (p: P) => Observable<KubernetesResourceList<R>>;\n    polling: number;\n    limit: number;\n  }) {\n    const load$ = merge(\n      queryParams$.pipe(\n        map(queryParams => () => ({ queryParams, action: LoadAction.Reload })),\n      ),\n      this.reloadAction$$.pipe(\n        map(silent => (prev: { queryParams?: P; action?: LoadAction }) => ({\n          ...prev,\n          action: silent ? LoadAction.SilentReload : LoadAction.Reload,\n        })),\n      ),\n    ).pipe(\n      scan(\n        (acc, scanner) => scanner(acc),\n        {} as { queryParams?: P; action?: LoadAction },\n      ),\n      tap(({ action, queryParams }) => {\n        if (action === LoadAction.Reload) {\n          this.snapshot = {\n            queryParams,\n          };\n          this.bypassItems$.next(null);\n        }\n      }),\n    );\n\n    return load$.pipe(\n      // eslint-disable-next-line sonarjs/cognitive-complexity\n      switchMap(({ action: leadAction, queryParams }) =>\n        this.loadMoreAction$$.pipe(\n          filter(() => this.snapshot.hasMore),\n          map(() => true),\n          startWith(false),\n          exhaustMap(loadMore => {\n            if (this.timer) {\n              window.clearTimeout(this.timer);\n            }\n            const token = this.snapshot.continueToken;\n            const hasMore = this.snapshot.hasMore;\n            const currLength = this.snapshot.items?.length ?? limit;\n            const action = loadMore ? LoadAction.LoadMore : leadAction;\n            return fetcher(\n              normalizeParams({\n                limit: `${\n                  action === LoadAction.SilentReload\n                    ? hasMore\n                      ? currLength\n                      : 0\n                    : limit\n                }`,\n                continue: action === LoadAction.LoadMore ? token : '',\n                ...queryParams,\n              }) as P,\n            ).pipe(\n              map(rawResponse => ({ rawResponse, loadingError: null })),\n              catchError((err: Status | HttpErrorResponse) =>\n                of({\n                  loadingError: action === LoadAction.SilentReload ? null : err,\n                }),\n              ),\n              tap(res => {\n                if (polling && !res.loadingError) {\n                  this.timer = window.setTimeout(() => {\n                    this.reload(true);\n                  }, polling);\n                }\n              }),\n              map(state => ({\n                ...state,\n                action,\n              })),\n              startWith({\n                action,\n                loading: true,\n              }),\n            );\n          }),\n        ),\n      ),\n      map(state => ({\n        action: LoadAction.LoadMore,\n        rawResponse: null,\n        loading: false,\n        loadingError: null,\n        ...state,\n      })),\n      tap(state => {\n        this.snapshot.rawResponse = state.rawResponse;\n        this.snapshot.loadingError = state.loadingError;\n        this.snapshot.loading =\n          state.loading && state.action !== LoadAction.SilentReload;\n        this.snapshot.continueToken = this.extractContinueTokenFromState(state);\n        this.snapshot.hasMore = !!this.snapshot.continueToken;\n      }),\n      finalize(() => {\n        this.snapshot = {};\n        this.bypassItems$.next(null);\n        if (this.timer) {\n          window.clearTimeout(this.timer);\n        }\n      }),\n      takeUntil(this.destroy$$),\n      publishRef(),\n    );\n  }\n\n  private extractContinueTokenFromState({\n    rawResponse,\n    loadingError,\n  }: LoadState<KubernetesResourceList<R>>) {\n    if (rawResponse) {\n      return rawResponse.metadata?.continue ?? '';\n    }\n\n    if (loadingError && 'code' in loadingError && loadingError.code === 410) {\n      return loadingError.metadata?.continue;\n    }\n\n    return this.snapshot.continueToken;\n  }\n\n  // eslint-disable-next-line sonarjs/cognitive-complexity\n  private initStreams(watcher: Watcher<R, Q>) {\n    this.rawResponse$ = this.loadState$.pipe(\n      map(data => data.rawResponse),\n      distinctUntilChanged(),\n      publishRef(),\n    );\n\n    this.loading$ = this.loadState$.pipe(\n      map(\n        ({ loading, action }) => loading && action !== LoadAction.SilentReload,\n      ),\n      distinctUntilChanged(),\n      publishRef(),\n    );\n\n    this.loadingError$ = this.loadState$.pipe(\n      map(state => state.loadingError),\n      distinctUntilChanged(),\n      publishRef(),\n    );\n\n    this.continueToken$ = this.loadState$.pipe(\n      filter(({ loading }) => !loading),\n      switchMap(({ rawResponse, loadingError: err }) => {\n        if (rawResponse) {\n          return of(rawResponse.metadata?.continue ?? '');\n        }\n        if (err && 'code' in err && err.code === 410) {\n          return of(err.metadata?.continue);\n        }\n        return EMPTY;\n      }),\n      distinctUntilChanged(),\n      publishRef(),\n    );\n\n    this.hasMore$ = this.continueToken$.pipe(\n      map(token => !!token),\n      distinctUntilChanged(),\n      publishRef(),\n    );\n\n    this.items$ = merge(\n      this.loadState$.pipe(\n        map(state => (items: R[]) => {\n          const newItems = state.rawResponse\n            ? state.rawResponse.items ?? []\n            : null;\n          if (state.action === LoadAction.Reload) {\n            return newItems ?? [];\n          }\n          if (state.action === LoadAction.SilentReload) {\n            return newItems ?? items;\n          }\n          if (state.action === LoadAction.LoadMore) {\n            return newItems ? [...items, ...newItems] : items;\n          }\n          return items;\n        }),\n      ),\n      this.itemsScanner$$,\n      watcher ? this.buildWatcher(watcher) : EMPTY,\n    ).pipe(\n      scan<ItemsScanner<R>, R[]>((acc, scanner) => scanner(acc), []),\n      tap(items => {\n        this.snapshot.items = items;\n        this.bypassItems$.next(items);\n      }),\n      takeUntil(this.destroy$$),\n      publishRef(),\n    );\n  }\n\n  private buildWatcher(watcher: Watcher<R, Q>) {\n    return this.rawResponse$.pipe(\n      filter(res => !!res),\n      distinctUntilChanged(\n        (a, b) => a.metadata?.resourceVersion === b.metadata?.resourceVersion,\n      ),\n      switchMap(list =>\n        watcher(list.metadata?.resourceVersion, this.snapshot.queryParams).pipe(\n          catchError(() => {\n            this.reload(true);\n            return EMPTY;\n          }),\n        ),\n      ),\n      switchMap(({ type, object: resource }) => {\n        switch (type) {\n          case WatchEvent.Added: {\n            return of(this._create(resource));\n          }\n          case WatchEvent.Modified: {\n            return of(this._update(resource));\n          }\n          case WatchEvent.Deleted: {\n            return of(this._delete(resource));\n          }\n          default: {\n            return EMPTY;\n          }\n        }\n      }),\n    );\n  }\n}\n\nfunction defaultInsert<T extends KubernetesResource>(\n  items: T[],\n  res: T,\n  hasMore: boolean,\n) {\n  for (let i = 0; i < items.length; i++) {\n    const compare = resourceCompare(res, items[i]);\n    if (compare === 0) {\n      return items.map((item, index) => (index === i ? res : item));\n    }\n    if (compare < 0) {\n      return [...items.slice(0, i), res, ...items.slice(i)];\n    }\n  }\n\n  return hasMore ? items : [...items, res];\n}\n\nfunction resourceCompare(a: KubernetesResource, b: KubernetesResource) {\n  const nsCompare =\n    a.metadata.namespace?.localeCompare(b.metadata.namespace) ?? 0;\n  return nsCompare === 0\n    ? a.metadata.name.localeCompare(b.metadata.name)\n    : nsCompare;\n}\n"]}

package/esm2022/k8s-resource-list/k8s-resource-list.module.mjs

@@ -0,0 +1,43 @@
+/**
+ * @packageDocumentation
+ * @module k8s-resource-list
+ */
+import { BackTopModule, ButtonModule, IconModule } from '@alauda/ui';
+import { CommonModule } from '@angular/common';
+import { NgModule } from '@angular/core';
+import { TranslateModule } from '../translate/public-api';
+import { K8SResourceListFooterComponent, K8sListFooterNoDataDirective, } from './footer/component';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "@alauda/ui";
+import * as i3 from "../translate/translate.pipe";
+export class K8SResourceListModule {
+    static { this.ɵfac = function K8SResourceListModule_Factory(t) { return new (t || K8SResourceListModule)(); }; }
+    static { this.ɵmod = /*@__PURE__*/ i0.ɵɵdefineNgModule({ type: K8SResourceListModule }); }
+    static { this.ɵinj = /*@__PURE__*/ i0.ɵɵdefineInjector({ imports: [CommonModule,
+            ButtonModule,
+            IconModule,
+            BackTopModule,
+            TranslateModule] }); }
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(K8SResourceListModule, [{
+        type: NgModule,
+        args: [{
+                imports: [
+                    CommonModule,
+                    ButtonModule,
+                    IconModule,
+                    BackTopModule,
+                    TranslateModule,
+                ],
+                declarations: [K8SResourceListFooterComponent, K8sListFooterNoDataDirective],
+                exports: [K8SResourceListFooterComponent, K8sListFooterNoDataDirective],
+            }]
+    }], null, null); })();
+(function () { (typeof ngJitMode === "undefined" || ngJitMode) && i0.ɵɵsetNgModuleScope(K8SResourceListModule, { declarations: [K8SResourceListFooterComponent, K8sListFooterNoDataDirective], imports: [CommonModule,
+        ButtonModule,
+        IconModule,
+        BackTopModule,
+        TranslateModule], exports: [K8SResourceListFooterComponent, K8sListFooterNoDataDirective] }); })();
+i0.ɵɵsetComponentScope(K8SResourceListFooterComponent, [i1.NgIf, i1.NgTemplateOutlet, i2.ButtonComponent, i2.IconComponent, i2.BackTopComponent], [i1.AsyncPipe, i3.TranslatePipe]);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiazhzLXJlc291cmNlLWxpc3QubW9kdWxlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vbGlicy9jb21tb24vc3JjL2s4cy1yZXNvdXJjZS1saXN0L2s4cy1yZXNvdXJjZS1saXN0Lm1vZHVsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7O0dBR0c7QUFFSCxPQUFPLEVBQUUsYUFBYSxFQUFFLFlBQVksRUFBRSxVQUFVLEVBQUUsTUFBTSxZQUFZLENBQUM7QUFDckUsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLGlCQUFpQixDQUFDO0FBQy9DLE9BQU8sRUFBRSxRQUFRLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFFekMsT0FBTyxFQUFFLGVBQWUsRUFBRSxNQUFNLHlCQUF5QixDQUFDO0FBRTFELE9BQU8sRUFDTCw4QkFBOEIsRUFDOUIsNEJBQTRCLEdBQzdCLE1BQU0sb0JBQW9CLENBQUM7Ozs7O0FBYTVCLE1BQU0sT0FBTyxxQkFBcUI7c0ZBQXJCLHFCQUFxQjttRUFBckIscUJBQXFCO3VFQVQ5QixZQUFZO1lBQ1osWUFBWTtZQUNaLFVBQVU7WUFDVixhQUFhO1lBQ2IsZUFBZTs7dUZBS04scUJBQXFCO2NBWGpDLFFBQVE7ZUFBQztnQkFDUixPQUFPLEVBQUU7b0JBQ1AsWUFBWTtvQkFDWixZQUFZO29CQUNaLFVBQVU7b0JBQ1YsYUFBYTtvQkFDYixlQUFlO2lCQUNoQjtnQkFDRCxZQUFZLEVBQUUsQ0FBQyw4QkFBOEIsRUFBRSw0QkFBNEIsQ0FBQztnQkFDNUUsT0FBTyxFQUFFLENBQUMsOEJBQThCLEVBQUUsNEJBQTRCLENBQUM7YUFDeEU7O3dGQUNZLHFCQUFxQixtQkFIakIsOEJBQThCLEVBQUUsNEJBQTRCLGFBTnpFLFlBQVk7UUFDWixZQUFZO1FBQ1osVUFBVTtRQUNWLGFBQWE7UUFDYixlQUFlLGFBR1AsOEJBQThCLEVBQUUsNEJBQTRCO3VCQUR2RCw4QkFBOEIiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEBwYWNrYWdlRG9jdW1lbnRhdGlvblxuICogQG1vZHVsZSBrOHMtcmVzb3VyY2UtbGlzdFxuICovXG5cbmltcG9ydCB7IEJhY2tUb3BNb2R1bGUsIEJ1dHRvbk1vZHVsZSwgSWNvbk1vZHVsZSB9IGZyb20gJ0BhbGF1ZGEvdWknO1xuaW1wb3J0IHsgQ29tbW9uTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvY29tbW9uJztcbmltcG9ydCB7IE5nTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5cbmltcG9ydCB7IFRyYW5zbGF0ZU1vZHVsZSB9IGZyb20gJy4uL3RyYW5zbGF0ZS9wdWJsaWMtYXBpJztcblxuaW1wb3J0IHtcbiAgSzhTUmVzb3VyY2VMaXN0Rm9vdGVyQ29tcG9uZW50LFxuICBLOHNMaXN0Rm9vdGVyTm9EYXRhRGlyZWN0aXZlLFxufSBmcm9tICcuL2Zvb3Rlci9jb21wb25lbnQnO1xuXG5ATmdNb2R1bGUoe1xuICBpbXBvcnRzOiBbXG4gICAgQ29tbW9uTW9kdWxlLFxuICAgIEJ1dHRvbk1vZHVsZSxcbiAgICBJY29uTW9kdWxlLFxuICAgIEJhY2tUb3BNb2R1bGUsXG4gICAgVHJhbnNsYXRlTW9kdWxlLFxuICBdLFxuICBkZWNsYXJhdGlvbnM6IFtLOFNSZXNvdXJjZUxpc3RGb290ZXJDb21wb25lbnQsIEs4c0xpc3RGb290ZXJOb0RhdGFEaXJlY3RpdmVdLFxuICBleHBvcnRzOiBbSzhTUmVzb3VyY2VMaXN0Rm9vdGVyQ29tcG9uZW50LCBLOHNMaXN0Rm9vdGVyTm9EYXRhRGlyZWN0aXZlXSxcbn0pXG5leHBvcnQgY2xhc3MgSzhTUmVzb3VyY2VMaXN0TW9kdWxlIHt9XG4iXX0=

package/esm2022/k8s-resource-list/k8s-resource-paged-list.mjs

@@ -0,0 +1,176 @@
+import { publishRef } from '@alauda/ui';
+import { inject } from '@angular/core';
+import { toObservable, toSignal } from '@angular/core/rxjs-interop';
+import { ActivatedRoute, Router } from '@angular/router';
+import { NEVER, Subject, catchError, filter, interval, isObservable, map, of, startWith, switchMap, switchScan, take, withLatestFrom, } from 'rxjs';
+import { WatchEvent } from '../api/public-api';
+import { DOWNGRADE_WATCH_ENABLED, DOWNGRADE_WATCH_POLLING, } from '../core';
+export class K8SResourcePagedList {
+    constructor(config) {
+        this.config = config;
+        this.reload$$ = new Subject();
+        this.addedUid = new Set();
+        this.deletedUid = new Set();
+        this.params$ = isObservable(this.config.params)
+            ? this.config.params
+            : toObservable(this.config.params);
+        this.loadState$ = this.config.watcher && !DOWNGRADE_WATCH_ENABLED
+            ? this.loadStateWithWatcher()
+            : this.config.watcher || this.config.polling
+                ? this.loadStateWithPolling()
+                : this.sourceLoadState();
+        this.loading$ = this.loadState$.pipe(map(state => state.loading));
+        this.items$ = this.loadState$.pipe(map(state => state.items));
+        this.totalItems$ = this.loadState$.pipe(map(state => state.totalItems));
+        this.loadError$ = this.loadState$.pipe(map(state => state.loadError));
+        this.$loading = toSignal(this.loading$);
+        this.$items = toSignal(this.items$);
+        this.$totalItems = toSignal(this.totalItems$);
+        this.$loadError = toSignal(this.loadError$);
+    }
+    reload() {
+        this.reload$$.next();
+    }
+    sourceLoadState() {
+        return this.params$.pipe(map(parseListParams), switchMap(({ listParams, extraParams }) => {
+            return this.reload$$.pipe(startWith(null), switchMap(() => {
+                return this.config.fetcher(listParams, extraParams).pipe(map(list => ({
+                    loading: false,
+                    loadSuccess: true,
+                    items: list.items ?? [],
+                    totalItems: list.metadata.totalItems ?? 0,
+                })), startWith({
+                    loading: true,
+                    loadSuccess: false,
+                    items: [],
+                    totalItems: 0,
+                }), catchError((err) => of({
+                    loading: false,
+                    loadSuccess: false,
+                    loadError: err,
+                    items: [],
+                    totalItems: 0,
+                })));
+            }));
+        }), publishRef());
+    }
+    loadStateWithPolling() {
+        return this.sourceLoadState().pipe(switchMap(sourceState => sourceState.loadSuccess
+            ? interval(this.config.polling || DOWNGRADE_WATCH_POLLING).pipe(withLatestFrom(this.params$), map(([_, params]) => parseListParams(params)), switchMap(({ listParams, extraParams }) => this.config.fetcher(listParams, extraParams).pipe(map(list => ({
+                ...sourceState,
+                items: list.items,
+                totalItems: list.metadata.totalItems,
+            })), catchError(() => NEVER))), startWith(sourceState))
+            : of(sourceState)), publishRef());
+    }
+    loadStateWithWatcher() {
+        return this.sourceLoadState().pipe(
+        // eslint-disable-next-line sonarjs/cognitive-complexity
+        switchMap(sourceState => sourceState.loadSuccess
+            ? this.params$.pipe(take(1), switchMap(params => {
+                const watchParams = parseListParams({
+                    keyword: params.keyword,
+                    extra: params.extra,
+                });
+                const fetchParams = parseListParams(params);
+                return this.config
+                    .watcher(watchParams.listParams, watchParams.extraParams)
+                    .pipe(filter(({ type, object }) => {
+                    switch (type) {
+                        case WatchEvent.Added: {
+                            if (this.addedUid.has(object.metadata.uid)) {
+                                return false;
+                            }
+                            this.addedUid.add(object.metadata.uid);
+                            return true;
+                        }
+                        case WatchEvent.Deleted: {
+                            if (this.deletedUid.has(object.metadata.uid)) {
+                                return false;
+                            }
+                            this.deletedUid.add(object.metadata.uid);
+                            return true;
+                        }
+                        default: {
+                            return true;
+                        }
+                    }
+                }), switchScan((state, { type, object }) => {
+                    switch (type) {
+                        case WatchEvent.Modified: {
+                            return of({
+                                ...state,
+                                items: state.items.map(item => item.metadata.uid === object.metadata.uid
+                                    ? object
+                                    : item),
+                            });
+                        }
+                        case WatchEvent.Added:
+                        case WatchEvent.Deleted: {
+                            return this.config
+                                .fetcher(fetchParams.listParams, fetchParams.extraParams)
+                                .pipe(map(list => ({
+                                ...state,
+                                items: list.items,
+                                totalItems: list.metadata.totalItems,
+                            })), catchError(() => NEVER));
+                        }
+                        default: {
+                            return NEVER;
+                        }
+                    }
+                }, sourceState));
+            }), startWith(sourceState))
+            : of(sourceState)), publishRef());
+    }
+}
+export function extractPagedListParams(defaultParams = {}, extraParams) {
+    const route = inject(ActivatedRoute);
+    const params$ = route.queryParams.pipe(map(params => ({
+        pageIndex: 0,
+        pageSize: 20,
+        ...defaultParams,
+        ...(params.pageIndex ? { pageIndex: params.pageIndex } : {}),
+        ...(params.pageSize ? { pageSize: params.pageSize } : {}),
+        ...(params.keyword ? { keyword: params.keyword } : {}),
+        ...(params.sortField ? { sortField: params.sortField } : {}),
+        ...(params.sortOrder ? { sortOrder: params.sortOrder } : {}),
+        ...(params.fieldSelector ? { fieldSelector: params.fieldSelector } : {}),
+        ...(params.labelSelector ? { labelSelector: params.labelSelector } : {}),
+        ...(extraParams ? { extra: extraParams(params) } : {}),
+    })));
+    return {
+        stream: () => params$,
+        signal: () => toSignal(params$),
+    };
+}
+export function queryListParams() {
+    const router = inject(Router);
+    const route = inject(ActivatedRoute);
+    return (queryParams) => {
+        router.navigate(['./'], {
+            relativeTo: route,
+            queryParamsHandling: 'merge',
+            queryParams,
+        });
+    };
+}
+function parseListParams({ pageIndex, pageSize, sortField, sortOrder, keyword, fieldSelector: originFieldSelector, labelSelector, extra: extraParams, }) {
+    const search = keyword ? `search=${keyword}` : '';
+    const sortBy = sortField
+        ? `sortby=${sortOrder === 'desc' ? '-' : ''}${sortField}`
+        : '';
+    const fieldSelector = [search, sortBy, originFieldSelector]
+        .filter(v => !!v)
+        .join(',');
+    return {
+        listParams: {
+            limit: (pageSize || 20) + '',
+            continue: +(pageIndex || 0) * +(pageSize || 20) + '',
+            ...(labelSelector ? { labelSelector } : {}),
+            ...(fieldSelector ? { fieldSelector } : {}),
+        },
+        extraParams,
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"k8s-resource-paged-list.js","sourceRoot":"","sources":["../../../../../libs/common/src/k8s-resource-list/k8s-resource-paged-list.ts"],"names":[],"mappings":"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","sourcesContent":["import { publishRef } from '@alauda/ui';\nimport { HttpErrorResponse } from '@angular/common/http';\nimport { Signal, inject } from '@angular/core';\nimport { toObservable, toSignal } from '@angular/core/rxjs-interop';\nimport { ActivatedRoute, Params, Router } from '@angular/router';\nimport {\n  NEVER,\n  Observable,\n  Subject,\n  catchError,\n  filter,\n  interval,\n  isObservable,\n  map,\n  of,\n  startWith,\n  switchMap,\n  switchScan,\n  take,\n  withLatestFrom,\n} from 'rxjs';\n\nimport { WatchAPIResponse, WatchEvent } from '../api/public-api';\nimport {\n  DOWNGRADE_WATCH_ENABLED,\n  DOWNGRADE_WATCH_POLLING,\n  KubernetesResource,\n  KubernetesResourceList,\n  Status,\n} from '../core';\n\nexport class K8SResourcePagedList<\n  R extends KubernetesResource = KubernetesResource,\n  P = unknown,\n> {\n  private readonly reload$$ = new Subject<void>();\n  private readonly addedUid = new Set<string>();\n  private readonly deletedUid = new Set<string>();\n\n  params$ = isObservable(this.config.params)\n    ? this.config.params\n    : toObservable(this.config.params);\n\n  loadState$ =\n    this.config.watcher && !DOWNGRADE_WATCH_ENABLED\n      ? this.loadStateWithWatcher()\n      : this.config.watcher || this.config.polling\n      ? this.loadStateWithPolling()\n      : this.sourceLoadState();\n\n  loading$ = this.loadState$.pipe(map(state => state.loading));\n  items$ = this.loadState$.pipe(map(state => state.items));\n  totalItems$ = this.loadState$.pipe(map(state => state.totalItems));\n  loadError$ = this.loadState$.pipe(map(state => state.loadError));\n\n  $loading = toSignal(this.loading$);\n  $items = toSignal(this.items$);\n  $totalItems = toSignal(this.totalItems$);\n  $loadError = toSignal(this.loadError$);\n\n  constructor(private readonly config: PagedListConfig<R, P>) {}\n\n  reload() {\n    this.reload$$.next();\n  }\n\n  private sourceLoadState() {\n    return this.params$.pipe(\n      map(parseListParams),\n      switchMap(({ listParams, extraParams }) => {\n        return this.reload$$.pipe(\n          startWith(null),\n          switchMap((): Observable<LoadState<R>> => {\n            return this.config.fetcher(listParams, extraParams).pipe(\n              map(list => ({\n                loading: false,\n                loadSuccess: true,\n                items: list.items ?? [],\n                totalItems: list.metadata.totalItems ?? 0,\n              })),\n              startWith({\n                loading: true,\n                loadSuccess: false,\n                items: [],\n                totalItems: 0,\n              }),\n              catchError((err: Status | HttpErrorResponse) =>\n                of({\n                  loading: false,\n                  loadSuccess: false,\n                  loadError: err,\n                  items: [],\n                  totalItems: 0,\n                }),\n              ),\n            );\n          }),\n        );\n      }),\n      publishRef(),\n    );\n  }\n\n  private loadStateWithPolling(): Observable<LoadState<R>> {\n    return this.sourceLoadState().pipe(\n      switchMap(sourceState =>\n        sourceState.loadSuccess\n          ? interval(this.config.polling || DOWNGRADE_WATCH_POLLING).pipe(\n              withLatestFrom(this.params$),\n              map(([_, params]) => parseListParams(params)),\n              switchMap(({ listParams, extraParams }) =>\n                this.config.fetcher(listParams, extraParams).pipe(\n                  map(list => ({\n                    ...sourceState,\n                    items: list.items,\n                    totalItems: list.metadata.totalItems,\n                  })),\n                  catchError(() => NEVER),\n                ),\n              ),\n              startWith(sourceState),\n            )\n          : of(sourceState),\n      ),\n      publishRef(),\n    );\n  }\n\n  private loadStateWithWatcher(): Observable<LoadState<R>> {\n    return this.sourceLoadState().pipe(\n      // eslint-disable-next-line sonarjs/cognitive-complexity\n      switchMap(sourceState =>\n        sourceState.loadSuccess\n          ? this.params$.pipe(\n              take(1),\n              switchMap(params => {\n                const watchParams = parseListParams({\n                  keyword: params.keyword,\n                  extra: params.extra,\n                });\n                const fetchParams = parseListParams(params);\n                return this.config\n                  .watcher(watchParams.listParams, watchParams.extraParams)\n                  .pipe(\n                    filter(({ type, object }) => {\n                      switch (type) {\n                        case WatchEvent.Added: {\n                          if (this.addedUid.has(object.metadata.uid)) {\n                            return false;\n                          }\n                          this.addedUid.add(object.metadata.uid);\n                          return true;\n                        }\n                        case WatchEvent.Deleted: {\n                          if (this.deletedUid.has(object.metadata.uid)) {\n                            return false;\n                          }\n                          this.deletedUid.add(object.metadata.uid);\n                          return true;\n                        }\n                        default: {\n                          return true;\n                        }\n                      }\n                    }),\n                    switchScan((state, { type, object }) => {\n                      switch (type) {\n                        case WatchEvent.Modified: {\n                          return of({\n                            ...state,\n                            items: state.items.map(item =>\n                              item.metadata.uid === object.metadata.uid\n                                ? object\n                                : item,\n                            ),\n                          });\n                        }\n                        case WatchEvent.Added:\n                        case WatchEvent.Deleted: {\n                          return this.config\n                            .fetcher(\n                              fetchParams.listParams,\n                              fetchParams.extraParams,\n                            )\n                            .pipe(\n                              map(list => ({\n                                ...state,\n                                items: list.items,\n                                totalItems: list.metadata.totalItems,\n                              })),\n                              catchError(() => NEVER),\n                            );\n                        }\n                        default: {\n                          return NEVER;\n                        }\n                      }\n                    }, sourceState),\n                  );\n              }),\n              startWith(sourceState),\n            )\n          : of(sourceState),\n      ),\n      publishRef(),\n    );\n  }\n}\n\nexport interface PagedListConfig<R, P> {\n  params: Signal<ListFetchParams<P>> | Observable<ListFetchParams<P>>;\n  fetcher: (\n    listParams: FetchSeed,\n    extraParams: P,\n  ) => Observable<KubernetesResourceList<R>>;\n  watcher?: (\n    listParams: FetchSeed,\n    extraParams: P,\n  ) => Observable<WatchAPIResponse<R>>;\n  polling?: number;\n}\n\nexport interface ListFetchParams<P = never> {\n  pageIndex?: number | string;\n  pageSize?: number | string;\n  sortField?: string;\n  sortOrder?: 'asc' | 'desc';\n  keyword?: string;\n  fieldSelector?: string;\n  labelSelector?: string;\n  extra?: P;\n}\n\nexport interface FetchSeed extends Record<string, string> {\n  limit?: string;\n  continue?: string;\n  fieldSelector?: string;\n}\n\ninterface LoadState<R> {\n  items: R[];\n  totalItems: number;\n  loading: boolean;\n  loadSuccess: boolean;\n  loadError?: HttpErrorResponse | Status;\n}\n\nexport function extractPagedListParams<P>(\n  defaultParams: ListFetchParams = {},\n  extraParams?: (queryParams: Params) => P,\n): Readonly<{\n  stream: () => Observable<ListFetchParams<P>>;\n  signal: () => Signal<ListFetchParams<P>>;\n}> {\n  const route = inject(ActivatedRoute);\n  const params$ = route.queryParams.pipe(\n    map(params => ({\n      pageIndex: 0,\n      pageSize: 20,\n      ...defaultParams,\n      ...(params.pageIndex ? { pageIndex: params.pageIndex } : {}),\n      ...(params.pageSize ? { pageSize: params.pageSize } : {}),\n      ...(params.keyword ? { keyword: params.keyword } : {}),\n      ...(params.sortField ? { sortField: params.sortField } : {}),\n      ...(params.sortOrder ? { sortOrder: params.sortOrder } : {}),\n      ...(params.fieldSelector ? { fieldSelector: params.fieldSelector } : {}),\n      ...(params.labelSelector ? { labelSelector: params.labelSelector } : {}),\n      ...(extraParams ? { extra: extraParams(params) } : {}),\n    })),\n  );\n\n  return {\n    stream: () => params$,\n    signal: () => toSignal(params$),\n  };\n}\n\nexport function queryListParams() {\n  const router = inject(Router);\n  const route = inject(ActivatedRoute);\n\n  return (queryParams: Params) => {\n    router.navigate(['./'], {\n      relativeTo: route,\n      queryParamsHandling: 'merge',\n      queryParams,\n    });\n  };\n}\n\nfunction parseListParams<P>({\n  pageIndex,\n  pageSize,\n  sortField,\n  sortOrder,\n  keyword,\n  fieldSelector: originFieldSelector,\n  labelSelector,\n  extra: extraParams,\n}: ListFetchParams<P>) {\n  const search = keyword ? `search=${keyword}` : '';\n  const sortBy = sortField\n    ? `sortby=${sortOrder === 'desc' ? '-' : ''}${sortField}`\n    : '';\n  const fieldSelector = [search, sortBy, originFieldSelector]\n    .filter(v => !!v)\n    .join(',');\n  return {\n    listParams: {\n      limit: (pageSize || 20) + '',\n      continue: +(pageIndex || 0) * +(pageSize || 20) + '',\n      ...(labelSelector ? { labelSelector } : {}),\n      ...(fieldSelector ? { fieldSelector } : {}),\n    } as FetchSeed,\n    extraParams,\n  };\n}\n"]}

package/esm2022/k8s-resource-list/public-api.mjs

@@ -0,0 +1,13 @@
+/**
+ * [[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';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL2xpYnMvY29tbW9uL3NyYy9rOHMtcmVzb3VyY2UtbGlzdC9wdWJsaWMtYXBpLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7O0dBSUc7QUFDSCxjQUFjO0FBQ2QsY0FBYyxvQkFBb0IsQ0FBQztBQUNuQyxjQUFjLHFCQUFxQixDQUFDO0FBQ3BDLGNBQWMsNEJBQTRCLENBQUM7QUFDM0MsY0FBYyxTQUFTLENBQUM7QUFDeEIsY0FBYyxTQUFTLENBQUM7QUFFeEIsY0FBYywyQkFBMkIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogW1tpbmNsdWRlOms4cy1yZXNvdXJjZS1saXN0L1JFQURNRS5tZF1dXG4gKiBAbW9kdWxlIGs4cy1yZXNvdXJjZS1saXN0XG4gKiBAcHJlZmVycmVkXG4gKi9cbi8qKiBpbXBvcnRzICovXG5leHBvcnQgKiBmcm9tICcuL2Zvb3Rlci9jb21wb25lbnQnO1xuZXhwb3J0ICogZnJvbSAnLi9rOHMtcmVzb3VyY2UtbGlzdCc7XG5leHBvcnQgKiBmcm9tICcuL2s4cy1yZXNvdXJjZS1saXN0Lm1vZHVsZSc7XG5leHBvcnQgKiBmcm9tICcuL3R5cGVzJztcbmV4cG9ydCAqIGZyb20gJy4vdXRpbHMnO1xuXG5leHBvcnQgKiBmcm9tICcuL2s4cy1yZXNvdXJjZS1wYWdlZC1saXN0JztcbiJdfQ==

package/esm2022/k8s-resource-list/types.mjs

@@ -0,0 +1,11 @@
+/**
+ * @packageDocumentation
+ * @module k8s-resource-list
+ */
+export var LoadAction;
+(function (LoadAction) {
+    LoadAction["Reload"] = "Reload";
+    LoadAction["SilentReload"] = "SilentReload";
+    LoadAction["LoadMore"] = "LoadMore";
+})(LoadAction || (LoadAction = {}));
+//# sourceMappingURL=data:application/json;base64,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