@k8slens/extensions 5.3.1-git.ae97e16e9d.0 → 5.3.1-git.b665a2efe7.0

package/dist/src/common/ipc/update-available.ipc.d.ts

@@ -20,6 +20,8 @@
  */
 import type { UpdateInfo } from "electron-updater";
 export declare const UpdateAvailableChannel = "update-available";
+export declare const AutoUpdateChecking = "auto-update:checking";
+export declare const AutoUpdateNoUpdateAvailable = "auto-update:no-update";
 export declare const AutoUpdateLogPrefix = "[UPDATE-CHECKER]";
 export declare type UpdateAvailableFromMain = [backChannel: string, updateInfo: UpdateInfo];
 export declare function areArgsUpdateAvailableFromMain(args: unknown[]): args is UpdateAvailableFromMain;

package/dist/src/common/k8s-api/cluster-context.d.ts

@@ -23,4 +23,5 @@ export interface ClusterContext {
     cluster?: Cluster;
     allNamespaces: string[];
     contextNamespaces: string[];
+    hasSelectedAll: boolean;
 }

package/dist/src/common/k8s-api/endpoints/daemon-set.api.d.ts

@@ -22,17 +22,14 @@ import { IAffinity, WorkloadKubeObject } from "../workload-kube-object";
 import { KubeApi } from "../kube-api";
 import type { KubeJsonApiData } from "../kube-json-api";
 import type { IPodContainer, IPodMetrics } from "./pods.api";
+import type { LabelSelector } from "../kube-object";
 export declare class DaemonSet extends WorkloadKubeObject {
     static kind: string;
     static namespaced: boolean;
     static apiBase: string;
     constructor(data: KubeJsonApiData);
     spec: {
-        selector: {
-            matchLabels: {
-                [name: string]: string;
-            };
-        };
+        selector: LabelSelector;
         template: {
             metadata: {
                 creationTimestamp?: string;

package/dist/src/common/k8s-api/endpoints/deployment.api.d.ts

@@ -22,6 +22,7 @@ import { IAffinity, WorkloadKubeObject } from "../workload-kube-object";
 import { KubeApi } from "../kube-api";
 import type { IPodMetrics } from "./pods.api";
 import type { KubeJsonApiData } from "../kube-json-api";
+import type { LabelSelector } from "../kube-object";
 export declare class DeploymentApi extends KubeApi<Deployment> {
     protected getScaleApiUrl(params: {
         namespace: string;
@@ -67,11 +68,7 @@ export declare class Deployment extends WorkloadKubeObject {
     constructor(data: KubeJsonApiData);
     spec: {
         replicas: number;
-        selector: {
-            matchLabels: {
-                [app: string]: string;
-            };
-        };
+        selector: LabelSelector;
         template: {
             metadata: {
                 creationTimestamp?: string;

package/dist/src/common/k8s-api/endpoints/job.api.d.ts

@@ -22,6 +22,7 @@ import { IAffinity, WorkloadKubeObject } from "../workload-kube-object";
 import { KubeApi } from "../kube-api";
 import type { KubeJsonApiData } from "../kube-json-api";
 import type { IPodContainer, IPodMetrics } from "./pods.api";
+import type { LabelSelector } from "../kube-object";
 export declare class Job extends WorkloadKubeObject {
     static kind: string;
     static namespaced: boolean;
@@ -31,11 +32,7 @@ export declare class Job extends WorkloadKubeObject {
         parallelism?: number;
         completions?: number;
         backoffLimit?: number;
-        selector?: {
-            matchLabels: {
-                [name: string]: string;
-            };
-        };
+        selector?: LabelSelector;
         template: {
             metadata: {
                 creationTimestamp?: string;

package/dist/src/common/k8s-api/endpoints/metrics.api.d.ts

@@ -55,6 +55,8 @@ export interface IResourceMetrics<T extends IMetrics> {
     cpuUsage: T;
     memoryUsage: T;
     fsUsage: T;
+    fsWrites: T;
+    fsReads: T;
     networkReceive: T;
     networkTransmit: T;
 }

package/dist/src/common/k8s-api/endpoints/network-policy.api.d.ts

@@ -18,50 +18,90 @@
  * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
-import { KubeObject } from "../kube-object";
+import { KubeObject, LabelSelector } from "../kube-object";
 import { KubeApi } from "../kube-api";
 import type { KubeJsonApiData } from "../kube-json-api";
 export interface IPolicyIpBlock {
     cidr: string;
     except?: string[];
 }
-export interface IPolicySelector {
-    matchLabels: {
-        [label: string]: string;
-    };
+/**
+ * @deprecated Use `LabelSelector` instead
+ */
+export declare type IPolicySelector = LabelSelector;
+export interface NetworkPolicyPort {
+    /**
+     * The protocol which network traffic must match.
+     *
+     * One of:
+     * - `"TCP"`
+     * - `"UDP"`
+     * - `"SCTP"`
+     *
+     * @default "TCP"
+     */
+    protocol?: string;
+    /**
+     * The port on the given protocol. This can either be a numerical or named
+     * port on a pod. If this field is not provided, this matches all port names and
+     * numbers.
+     *
+     * If present, only traffic on the specified protocol AND port will be matched.
+     */
+    port?: number | string;
+    /**
+     * If set, indicates that the range of ports from port to endPort, inclusive,
+     * should be allowed by the policy. This field cannot be defined if the port field
+     * is not defined or if the port field is defined as a named (string) port.
+     *
+     * The endPort must be equal or greater than port.
+     */
+    endPort?: number;
+}
+export interface NetworkPolicyPeer {
+    /**
+     * IPBlock defines policy on a particular IPBlock. If this field is set then
+     * neither of the other fields can be.
+     */
+    ipBlock?: IPolicyIpBlock;
+    /**
+     * Selects Namespaces using cluster-scoped labels. This field follows standard label
+     * selector semantics; if present but empty, it selects all namespaces.
+     *
+     * If PodSelector is also set, then the NetworkPolicyPeer as a whole selects
+     * the Pods matching PodSelector in the Namespaces selected by NamespaceSelector.
+     *
+     * Otherwise it selects all Pods in the Namespaces selected by NamespaceSelector.
+     */
+    namespaceSelector?: LabelSelector;
+    /**
+     * This is a label selector which selects Pods. This field follows standard label
+     * selector semantics; if present but empty, it selects all pods.
+     *
+     * If NamespaceSelector is also set, then the NetworkPolicyPeer as a whole selects
+     * the Pods matching PodSelector in the Namespaces selected by NamespaceSelector.
+     *
+     * Otherwise it selects the Pods matching PodSelector in the policy's own Namespace.
+     */
+    podSelector?: LabelSelector;
 }
 export interface IPolicyIngress {
-    from: {
-        ipBlock?: IPolicyIpBlock;
-        namespaceSelector?: IPolicySelector;
-        podSelector?: IPolicySelector;
-    }[];
-    ports: {
-        protocol: string;
-        port: number;
-    }[];
+    from?: NetworkPolicyPeer[];
+    ports?: NetworkPolicyPort[];
 }
 export interface IPolicyEgress {
-    to: {
-        ipBlock: IPolicyIpBlock;
-    }[];
-    ports: {
-        protocol: string;
-        port: number;
-    }[];
+    to?: NetworkPolicyPeer[];
+    ports?: NetworkPolicyPort[];
+}
+export declare type PolicyType = "Ingress" | "Egress";
+export interface NetworkPolicySpec {
+    podSelector: LabelSelector;
+    policyTypes?: PolicyType[];
+    ingress?: IPolicyIngress[];
+    egress?: IPolicyEgress[];
 }
 export interface NetworkPolicy {
-    spec: {
-        podSelector: {
-            matchLabels: {
-                [label: string]: string;
-                role: string;
-            };
-        };
-        policyTypes: string[];
-        ingress: IPolicyIngress[];
-        egress: IPolicyEgress[];
-    };
+    spec: NetworkPolicySpec;
 }
 export declare class NetworkPolicy extends KubeObject {
     static kind: string;

package/dist/src/common/k8s-api/endpoints/nodes.api.d.ts

@@ -66,17 +66,17 @@ export interface Node {
     status: {
         capacity?: {
             cpu: string;
-            ["ephemeral-storage"]: string;
-            ["hugepages-1Gi"]: string;
-            ["hugepages-2Mi"]: string;
+            "ephemeral-storage": string;
+            "hugepages-1Gi": string;
+            "hugepages-2Mi": string;
             memory: string;
             pods: string;
         };
         allocatable?: {
             cpu: string;
-            ["ephemeral-storage"]: string;
-            ["hugepages-1Gi"]: string;
-            ["hugepages-2Mi"]: string;
+            "ephemeral-storage": string;
+            "hugepages-1Gi": string;
+            "hugepages-2Mi": string;
             memory: string;
             pods: string;
         };

package/dist/src/common/k8s-api/endpoints/persistent-volume-claims.api.d.ts

@@ -18,7 +18,7 @@
  * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
-import { KubeObject } from "../kube-object";
+import { KubeObject, LabelSelector } from "../kube-object";
 import { IMetrics } from "./metrics.api";
 import type { Pod } from "./pods.api";
 import { KubeApi } from "../kube-api";
@@ -35,16 +35,7 @@ export interface PersistentVolumeClaim {
     spec: {
         accessModes: string[];
         storageClassName: string;
-        selector: {
-            matchLabels: {
-                release: string;
-            };
-            matchExpressions: {
-                key: string;
-                operator: string;
-                values: string[];
-            }[];
-        };
+        selector: LabelSelector;
         resources: {
             requests: {
                 storage: string;
@@ -63,11 +54,7 @@ export declare class PersistentVolumeClaim extends KubeObject {
     getPods(allPods: Pod[]): Pod[];
     getStorage(): string;
     getMatchLabels(): string[];
-    getMatchExpressions(): {
-        key: string;
-        operator: string;
-        values: string[];
-    }[];
+    getMatchExpressions(): import("../kube-object").LabelMatchExpression[];
     getStatus(): string;
 }
 declare let pvcApi: PersistentVolumeClaimsApi;

package/dist/src/common/k8s-api/endpoints/poddisruptionbudget.api.d.ts

@@ -18,18 +18,14 @@
  * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
-import { KubeObject } from "../kube-object";
+import { KubeObject, LabelSelector } from "../kube-object";
 import { KubeApi } from "../kube-api";
 import type { KubeJsonApiData } from "../kube-json-api";
 export interface PodDisruptionBudget {
     spec: {
         minAvailable: string;
         maxUnavailable: string;
-        selector: {
-            matchLabels: {
-                [app: string]: string;
-            };
-        };
+        selector: LabelSelector;
     };
     status: {
         currentHealthy: number;

package/dist/src/common/k8s-api/endpoints/pods.api.d.ts

@@ -34,6 +34,8 @@ export interface IPodMetrics<T = IMetrics> {
     cpuUsage: T;
     memoryUsage: T;
     fsUsage: T;
+    fsWrites: T;
+    fsReads: T;
     networkReceive: T;
     networkTransmit: T;
     cpuRequests?: T;

package/dist/src/common/k8s-api/endpoints/replica-set.api.d.ts

@@ -22,6 +22,7 @@ import { WorkloadKubeObject } from "../workload-kube-object";
 import { KubeApi } from "../kube-api";
 import type { IPodMetrics, Pod } from "./pods.api";
 import type { KubeJsonApiData } from "../kube-json-api";
+import type { LabelSelector } from "../kube-object";
 export declare class ReplicaSetApi extends KubeApi<ReplicaSet> {
     protected getScaleApiUrl(params: {
         namespace: string;
@@ -44,11 +45,7 @@ export declare class ReplicaSet extends WorkloadKubeObject {
     constructor(data: KubeJsonApiData);
     spec: {
         replicas?: number;
-        selector: {
-            matchLabels: {
-                [app: string]: string;
-            };
-        };
+        selector: LabelSelector;
         template?: {
             metadata: {
                 labels: {

package/dist/src/common/k8s-api/endpoints/stateful-set.api.d.ts

@@ -22,6 +22,7 @@ import { IAffinity, WorkloadKubeObject } from "../workload-kube-object";
 import { KubeApi } from "../kube-api";
 import type { IPodMetrics } from "./pods.api";
 import type { KubeJsonApiData } from "../kube-json-api";
+import type { LabelSelector } from "../kube-object";
 export declare class StatefulSetApi extends KubeApi<StatefulSet> {
     protected getScaleApiUrl(params: {
         namespace: string;
@@ -45,11 +46,7 @@ export declare class StatefulSet extends WorkloadKubeObject {
     spec: {
         serviceName: string;
         replicas: number;
-        selector: {
-            matchLabels: {
-                [key: string]: string;
-            };
-        };
+        selector: LabelSelector;
         template: {
             metadata: {
                 labels: {

package/dist/src/common/k8s-api/kube-api-parse.d.ts

@@ -28,7 +28,7 @@ export interface IKubeApiLinkRef {
     apiPrefix?: string;
     apiVersion: string;
     resource: string;
-    name: string;
+    name?: string;
     namespace?: string;
 }
 export interface IKubeApiParsed extends IKubeApiLinkRef {
@@ -37,4 +37,4 @@ export interface IKubeApiParsed extends IKubeApiLinkRef {
     apiVersionWithGroup: string;
 }
 export declare function parseKubeApi(path: string): IKubeApiParsed;
-export declare function createKubeApiURL(ref: IKubeApiLinkRef): string;
+export declare function createKubeApiURL({ apiPrefix, resource, apiVersion, name, namespace }: IKubeApiLinkRef): string;

package/dist/src/common/k8s-api/kube-api.d.ts

@@ -24,9 +24,14 @@ import { KubeJsonApi, KubeJsonApiData } from "./kube-json-api";
 import type { RequestInit } from "node-fetch";
 import AbortController from "abort-controller";
 import type { Patch } from "rfc6902";
+/**
+ * The options used for creating a `KubeApi`
+ */
 export interface IKubeApiOptions<T extends KubeObject> {
     /**
      * base api-path for listing all resources, e.g. "/api/v1/pods"
+     *
+     * If not specified then will be the one on the `objectConstructor`
      */
     apiBase?: string;
     /**
@@ -36,11 +41,29 @@ export interface IKubeApiOptions<T extends KubeObject> {
      * This option only has effect if checkPreferredVersion is true.
      */
     fallbackApiBases?: string[];
+    /**
+     * If `true` then will check all declared apiBases against the kube api server
+     * for the first accepted one.
+     */
+    checkPreferredVersion?: boolean;
+    /**
+     * The constructor for the kube objects returned from the API
+     */
     objectConstructor: KubeObjectConstructor<T>;
+    /**
+     * The api instance to use for making requests
+     *
+     * @default apiKube
+     */
     request?: KubeJsonApi;
+    /**
+     * @deprecated should be specified by `objectConstructor`
+     */
     isNamespaced?: boolean;
+    /**
+     * @deprecated should be specified by `objectConstructor`
+     */
     kind?: string;
-    checkPreferredVersion?: boolean;
 }
 export interface IKubeApiQueryParams {
     watch?: boolean | number;
@@ -81,6 +104,9 @@ export declare type PropagationPolicy = undefined | "Orphan" | "Foreground" | "B
  */
 export interface IKubeApiCluster extends ILocalKubeApiConfig {
 }
+export declare type PartialKubeObject<T extends KubeObject> = Partial<Omit<T, "metadata">> & {
+    metadata?: Partial<T["metadata"]>;
+};
 export interface IRemoteKubeApiConfig {
     cluster: {
         server: string;
@@ -106,14 +132,34 @@ export declare type KubeApiWatchOptions = {
     timeout?: number;
 };
 export declare type KubeApiPatchType = "merge" | "json" | "strategic";
+export interface ResourceDescriptor {
+    /**
+     * The name of the kubernetes resource
+     */
+    name: string;
+    /**
+     * The namespace that the resource lives in (if the resource is namespaced)
+     *
+     * Note: if not provided and the resource kind is namespaced, then this defaults to `"default"`
+     */
+    namespace?: string;
+}
+export interface DeleteResourceDescriptor extends ResourceDescriptor {
+    /**
+     * This determinines how child resources should be handled by kubernetes
+     *
+     * @default "Background"
+     */
+    propagationPolicy?: PropagationPolicy;
+}
 export declare class KubeApi<T extends KubeObject> {
     protected options: IKubeApiOptions<T>;
     readonly kind: string;
-    readonly apiBase: string;
-    readonly apiPrefix: string;
-    readonly apiGroup: string;
     readonly apiVersion: string;
-    readonly apiVersionPreferred?: string;
+    apiBase: string;
+    apiPrefix: string;
+    apiGroup: string;
+    apiVersionPreferred?: string;
     readonly apiResource: string;
     readonly isNamespaced: boolean;
     objectConstructor: KubeObjectConstructor<T>;
@@ -136,34 +182,16 @@ export declare class KubeApi<T extends KubeObject> {
     setResourceVersion(namespace: string, newVersion: string): void;
     getResourceVersion(namespace?: string): string;
     refreshResourceVersion(params?: KubeApiListOptions): Promise<T[]>;
-    getUrl({ name, namespace }?: {
-        name?: string;
-        namespace?: string;
-    }, query?: Partial<IKubeApiQueryParams>): string;
+    private computeApiBase;
+    getUrl({ name, namespace }?: Partial<ResourceDescriptor>, query?: Partial<IKubeApiQueryParams>): string;
     protected normalizeQuery(query?: Partial<IKubeApiQueryParams>): Partial<IKubeApiQueryParams>;
     protected parseResponse(data: unknown, namespace?: string): T | T[] | null;
     list({ namespace, reqInit }?: KubeApiListOptions, query?: IKubeApiQueryParams): Promise<T[] | null>;
-    get({ name, namespace }?: {
-        name?: string;
-        namespace?: string;
-    }, query?: IKubeApiQueryParams): Promise<T | null>;
-    create({ name, namespace }?: {
-        name?: string;
-        namespace?: string;
-    }, data?: Partial<T>): Promise<T | null>;
-    update({ name, namespace }?: {
-        name?: string;
-        namespace?: string;
-    }, data?: Partial<T>): Promise<T | null>;
-    patch({ name, namespace }?: {
-        name?: string;
-        namespace?: string;
-    }, data?: Partial<T> | Patch, strategy?: KubeApiPatchType): Promise<T | null>;
-    delete({ name, namespace, propagationPolicy }: {
-        name: string;
-        namespace?: string;
-        propagationPolicy?: PropagationPolicy;
-    }): Promise<KubeJsonApiData>;
+    get(desc: ResourceDescriptor, query?: IKubeApiQueryParams): Promise<T | null>;
+    create({ name, namespace }: Partial<ResourceDescriptor>, data?: PartialKubeObject<T>): Promise<T | null>;
+    update({ name, namespace }: ResourceDescriptor, data: PartialKubeObject<T>): Promise<T | null>;
+    patch(desc: ResourceDescriptor, data?: PartialKubeObject<T> | Patch, strategy?: KubeApiPatchType): Promise<T>;
+    delete({ propagationPolicy, ...desc }: DeleteResourceDescriptor): Promise<KubeJsonApiData>;
     getWatchUrl(namespace?: string, query?: IKubeApiQueryParams): string;
     watch(opts?: KubeApiWatchOptions): () => void;
     protected modifyWatchEvent(event: IKubeWatchEvent<KubeJsonApiData>): void;

package/dist/src/common/k8s-api/kube-json-api.d.ts

@@ -20,7 +20,6 @@
  */
 import { JsonApi, JsonApiData, JsonApiError } from "./json-api";
 import type { Response } from "node-fetch";
-import type { Cluster } from "../../main/cluster";
 export interface KubeJsonApiListMetadata {
     resourceVersion: string;
     selfLink?: string;
@@ -64,6 +63,6 @@ export interface KubeJsonApiError extends JsonApiError {
     };
 }
 export declare class KubeJsonApi extends JsonApi<KubeJsonApiData> {
-    static forCluster(cluster: Cluster): KubeJsonApi;
+    static forCluster(clusterId: string): KubeJsonApi;
     protected parseError(error: KubeJsonApiError | any, res: Response): string[];
 }

package/dist/src/common/k8s-api/kube-object.d.ts

@@ -81,9 +81,32 @@ export declare class KubeCreationError extends Error {
     data: any;
     constructor(message: string, data: any);
 }
+export declare type LabelMatchExpression = {
+    /**
+     * The label key that the selector applies to.
+     */
+    key: string;
+} & ({
+    /**
+     * This represents the key's relationship to a set of values.
+     */
+    operator: "Exists" | "DoesNotExist";
+    values?: undefined;
+} | {
+    operator: "In" | "NotIn";
+    /**
+     * The set of values for to match according to the operator for the label.
+     */
+    values: string[];
+});
+export interface LabelSelector {
+    matchLabels?: Record<string, string | undefined>;
+    matchExpressions?: LabelMatchExpression[];
+}
 export declare class KubeObject<Metadata extends KubeObjectMetadata = KubeObjectMetadata, Status = any, Spec = any> implements ItemObject {
-    static readonly kind: string;
-    static readonly namespaced: boolean;
+    static readonly kind?: string;
+    static readonly namespaced?: boolean;
+    static readonly apiBase?: string;
     apiVersion: string;
     kind: string;
     metadata: Metadata;

package/dist/src/common/k8s-api/kube-object.store.d.ts

@@ -25,10 +25,10 @@ import { ItemStore } from "../item.store";
 import { IKubeApiQueryParams, KubeApi } from "./kube-api";
 import type { KubeJsonApiData } from "./kube-json-api";
 import type { RequestInit } from "node-fetch";
+import AbortController from "abort-controller";
 import type { Patch } from "rfc6902";
-export interface KubeObjectStoreLoadingParams<K extends KubeObject> {
+export interface KubeObjectStoreLoadingParams {
     namespaces: string[];
-    api?: KubeApi<K>;
     reqInit?: RequestInit;
     /**
      * A function that is called when listing fails. If set then blocks errors
@@ -52,6 +52,10 @@ export interface KubeObjectStoreSubscribeParams {
      * being rejected with
      */
     onLoadFailure?: (err: any) => void;
+    /**
+     * An optional parent abort controller
+     */
+    abortController?: AbortController;
 }
 export declare abstract class KubeObjectStore<T extends KubeObject> extends ItemStore<T> {
     static defaultContext: import("mobx").IObservableValue<ClusterContext>;
@@ -78,16 +82,16 @@ export declare abstract class KubeObjectStore<T extends KubeObject> extends Item
     getByLabel(labels: string[] | {
         [label: string]: string;
     }): T[];
-    protected loadItems({ namespaces, api, reqInit, onLoadFailure }: KubeObjectStoreLoadingParams<T>): Promise<T[]>;
+    protected loadItems({ namespaces, reqInit, onLoadFailure }: KubeObjectStoreLoadingParams): Promise<T[]>;
     protected filterItemsOnLoad(items: T[]): T[];
-    loadAll(options?: KubeObjectStoreLoadAllParams): Promise<void | T[]>;
+    loadAll({ namespaces, merge, reqInit, onLoadFailure }?: KubeObjectStoreLoadAllParams): Promise<void | T[]>;
     reloadAll(opts?: {
         force?: boolean;
         namespaces?: string[];
         merge?: boolean;
     }): Promise<void | T[]>;
-    protected mergeItems(partialItems: T[], { replace, updateStore, sort, filter }?: {
-        replace?: boolean;
+    protected mergeItems(partialItems: T[], { merge, updateStore, sort, filter }?: {
+        merge?: boolean;
         updateStore?: boolean;
         sort?: boolean;
         filter?: boolean;
@@ -117,7 +121,7 @@ export declare abstract class KubeObjectStore<T extends KubeObject> extends Item
     removeSelectedItems(): Promise<void[]>;
     protected eventsBuffer: import("mobx").IObservableArray<IKubeWatchEvent<KubeJsonApiData>>;
     protected bindWatchEventsUpdater(delay?: number): void;
-    subscribe(opts?: KubeObjectStoreSubscribeParams): () => void;
+    subscribe({ onLoadFailure, abortController }?: KubeObjectStoreSubscribeParams): () => void;
     private watchNamespace;
     protected updateFromEventsBuffer(): void;
 }