@k8slens/extensions 5.3.1-git.4f33dfdfd5.0 → 5.3.1-git.4f75acf2b4.0

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;
 }

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

@@ -21,57 +21,34 @@
 import type { KubeObjectStore } from "./kube-object.store";
 import type { ClusterContext } from "./cluster-context";
 import { Disposer } from "../utils";
-import type { KubeApi } from "./kube-api";
 import type { KubeJsonApiData } from "./kube-json-api";
 import type { KubeObject } from "./kube-object";
 export interface IKubeWatchEvent<T extends KubeJsonApiData> {
     type: "ADDED" | "MODIFIED" | "DELETED" | "ERROR";
     object?: T;
 }
-interface KubeWatchPreloadOptions {
+export interface KubeWatchSubscribeStoreOptions {
     /**
      * The namespaces to watch
-     * @default all-accessible
+     * @default all selected namespaces
      */
     namespaces?: string[];
-    /**
-     * Whether to skip loading if the store is already loaded
-     * @default false
-     */
-    loadOnce?: boolean;
     /**
      * A function that is called when listing fails. If set then blocks errors
      * being rejected with
      */
     onLoadFailure?: (err: any) => void;
 }
-export interface KubeWatchSubscribeStoreOptions extends KubeWatchPreloadOptions {
-    /**
-     * Whether to subscribe only after loading all stores
-     * @default true
-     */
-    waitUntilLoaded?: boolean;
-    /**
-     * Whether to preload the stores before watching
-     * @default true
-     */
-    preload?: boolean;
-}
 export interface IKubeWatchLog {
     message: string | string[] | Error;
     meta?: object;
     cssStyle?: string;
 }
 export declare class KubeWatchApi {
-    context: ClusterContext;
-    constructor();
-    isAllowedApi(api: KubeApi<KubeObject>): boolean;
-    preloadStores(stores: KubeObjectStore<KubeObject>[], { loadOnce, namespaces, onLoadFailure }?: KubeWatchPreloadOptions): {
-        loading: Promise<PromiseSettledResult<any>[]>;
-        cancelLoading: () => void;
-    };
-    subscribeStores(stores: KubeObjectStore<KubeObject>[], opts?: KubeWatchSubscribeStoreOptions): Disposer;
-    protected log({ message, cssStyle, meta }: IKubeWatchLog): void;
+    #private;
+    static context: ClusterContext;
+    private subscribeStore;
+    subscribeStores(stores: KubeObjectStore<KubeObject>[], { namespaces, onLoadFailure }?: KubeWatchSubscribeStoreOptions): Disposer;
+    protected log(message: any, meta: any): void;
 }
 export declare const kubeWatchApi: KubeWatchApi;
-export {};

package/dist/src/common/protocol-handler/error.d.ts

@@ -27,13 +27,13 @@ export declare enum RoutingErrorType {
     NO_EXTENSION_ID = "no-ext-id",
     MISSING_EXTENSION = "missing-ext"
 }
-export declare class RoutingError extends Error {
+export declare class RoutingError<Query> extends Error {
     type: RoutingErrorType;
-    url: Url;
+    url: Url<Query>;
     /**
      * Will be set if the routing error originated in an extension route table
      */
     extensionName?: string;
-    constructor(type: RoutingErrorType, url: Url);
+    constructor(type: RoutingErrorType, url: Url<Query>);
     toString(): string;
 }

package/dist/src/common/protocol-handler/router.d.ts

@@ -19,8 +19,8 @@
  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 import { match } from "react-router";
-import { Singleton } from "../utils";
 import type Url from "url-parse";
+import type { ExtensionLoader as ExtensionLoaderType } from "../../extensions/extension-loader/extension-loader";
 import type { LensExtension } from "../../extensions/lens-extension";
 import type { RouteHandler } from "../../extensions/registries/protocol-handler";
 export declare const ProtocolHandlerIpcPrefix = "protocol-handler";
@@ -54,29 +54,34 @@ export declare enum RouteAttempt {
     MISSING_EXTENSION = "no-extension"
 }
 export declare function foldAttemptResults(mainAttempt: RouteAttempt, rendererAttempt: RouteAttempt): RouteAttempt;
-export declare abstract class LensProtocolRouter extends Singleton {
+interface Dependencies {
+    extensionLoader: ExtensionLoaderType;
+}
+export declare abstract class LensProtocolRouter {
+    protected dependencies: Dependencies;
     protected internalRoutes: Map<string, RouteHandler>;
     static readonly LoggingPrefix = "[PROTOCOL ROUTER]";
     static readonly ExtensionUrlSchema: string;
+    constructor(dependencies: Dependencies);
     /**
      * Attempts to route the given URL to all internal routes that have been registered
      * @param url the parsed URL that initiated the `lens://` protocol
      * @returns true if a route has been found
      */
-    protected _routeToInternal(url: Url): RouteAttempt;
+    protected _routeToInternal(url: Url<Record<string, string>>): RouteAttempt;
     /**
      * match against all matched URIs, returning either the first exact match or
      * the most specific match if none are exact.
      * @param routes the array of path schemas, handler pairs to match against
      * @param url the url (in its current state)
      */
-    protected _findMatchingRoute(routes: Iterable<[string, RouteHandler]>, url: Url): null | [match<Record<string, string>>, RouteHandler];
+    protected _findMatchingRoute(routes: Iterable<[string, RouteHandler]>, url: Url<Record<string, string>>): null | [match<Record<string, string>>, RouteHandler];
     /**
      * find the most specific matching handler and call it
      * @param routes the array of (path schemas, handler) pairs to match against
      * @param url the url (in its current state)
      */
-    protected _route(routes: Iterable<[string, RouteHandler]>, url: Url, extensionName?: string): RouteAttempt;
+    protected _route(routes: Iterable<[string, RouteHandler]>, url: Url<Record<string, string>>, extensionName?: string): RouteAttempt;
     /**
      * Tries to find the matching LensExtension instance
      *
@@ -84,7 +89,7 @@ export declare abstract class LensProtocolRouter extends Singleton {
      * @param url the protocol request URI that was "open"-ed
      * @returns either the found name or the instance of `LensExtension`
      */
-    protected _findMatchingExtensionByName(url: Url): Promise<LensExtension | string>;
+    protected _findMatchingExtensionByName(url: Url<Record<string, string>>): Promise<LensExtension | string>;
     /**
      * Find a matching extension by the first one or two path segments of `url` and then try to `_route`
      * its correspondingly registered handlers.
@@ -95,7 +100,7 @@ export declare abstract class LensProtocolRouter extends Singleton {
      * Note: this function modifies its argument, do not reuse
      * @param url the protocol request URI that was "open"-ed
      */
-    protected _routeToExtension(url: Url): Promise<RouteAttempt>;
+    protected _routeToExtension(url: Url<Record<string, string>>): Promise<RouteAttempt>;
     /**
      * Add a handler under the `lens://app` tree of routing.
      * @param pathSchema the URI path schema to match against for this handler
@@ -108,3 +113,4 @@ export declare abstract class LensProtocolRouter extends Singleton {
      */
     removeInternalHandler(urlSchema: string): void;
 }
+export {};

package/dist/src/common/user-store/preferences-helpers.d.ts

@@ -39,6 +39,19 @@ export interface DownloadMirror {
 }
 export declare const defaultPackageMirror = "default";
 export declare const packageMirrors: Map<string, DownloadMirror>;
+export declare enum ExtensionRegistryLocation {
+    DEFAULT = "default",
+    NPMRC = "npmrc",
+    CUSTOM = "custom"
+}
+export declare type ExtensionRegistry = {
+    location: ExtensionRegistryLocation.DEFAULT | ExtensionRegistryLocation.NPMRC;
+    customUrl?: undefined;
+} | {
+    location: ExtensionRegistryLocation.CUSTOM;
+    customUrl: string;
+};
+export declare const defaultExtensionRegistryUrl = "https://registry.npmjs.org";
 declare type PreferencesModelType<field extends keyof typeof DESCRIPTORS> = typeof DESCRIPTORS[field] extends PreferenceDescription<infer T, any> ? T : never;
 declare type UserStoreModelType<field extends keyof typeof DESCRIPTORS> = typeof DESCRIPTORS[field] extends PreferenceDescription<any, infer T> ? T : never;
 export declare type UserStoreFlatModel = {
@@ -65,6 +78,7 @@ export declare const DESCRIPTORS: {
     editorConfiguration: PreferenceDescription<EditorConfiguration, EditorConfiguration>;
     terminalCopyOnSelect: PreferenceDescription<boolean, boolean>;
     updateChannel: PreferenceDescription<string, string>;
+    extensionRegistryUrl: PreferenceDescription<ExtensionRegistry, ExtensionRegistry>;
 };
 export declare const CONSTANTS: {
     updateChannels: Map<string, {

package/dist/src/common/user-store/user-store.d.ts

@@ -20,7 +20,7 @@
  */
 import { BaseStore } from "../base-store";
 import { ObservableToggleSet } from "../../renderer/utils";
-import { EditorConfiguration, KubeconfigSyncValue, UserPreferencesModel } from "./preferences-helpers";
+import { EditorConfiguration, ExtensionRegistry, KubeconfigSyncValue, UserPreferencesModel } from "./preferences-helpers";
 export interface UserStoreModel {
     lastSeenAppVersion: string;
     preferences: UserPreferencesModel;
@@ -47,6 +47,7 @@ export declare class UserStore extends BaseStore<UserStoreModel> {
     kubectlBinariesPath?: string;
     terminalCopyOnSelect: boolean;
     updateChannel?: string;
+    extensionRegistryUrl: ExtensionRegistry;
     /**
      * Download kubectl binaries matching cluster version
      */

package/dist/src/common/utils/index.d.ts

@@ -44,6 +44,7 @@ export * from "./n-fircate";
 export * from "./objects";
 export * from "./openExternal";
 export * from "./paths";
+export * from "./promise-exec";
 export * from "./reject-promise";
 export * from "./singleton";
 export * from "./sort-compare";

package/dist/src/common/utils/promise-exec.d.ts

@@ -19,6 +19,5 @@
  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 /// <reference types="node" />
-import { exec, execFile } from "child_process";
-export declare const promiseExec: typeof exec.__promisify__;
+import { execFile } from "child_process";
 export declare const promiseExecFile: typeof execFile.__promisify__;

package/dist/src/common/utils/readableStream.d.ts

@@ -39,7 +39,7 @@ export declare class ReadableWebToNodeStream<T extends TypedArray> extends Reada
     private pendingRead;
     /**
      *
-     * @param stream Readable​Stream: https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream
+     * @param stream ReadableStream: https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream
      */
     constructor(stream: ReadableStream<T>);
     /**
@@ -50,7 +50,7 @@ export declare class ReadableWebToNodeStream<T extends TypedArray> extends Reada
      */
     _read(): Promise<void>;
     /**
-     * If there is no unresolved read call to Web-API Readable​Stream immediately returns;
+     * If there is no unresolved read call to Web-API ReadableStream immediately returns;
      * otherwise will wait until the read is resolved.
      */
     waitForReadToComplete(): Promise<void>;

package/dist/src/common/vars.d.ts

@@ -33,6 +33,7 @@ export declare const isIntegrationTesting: boolean;
 export declare const productName: string;
 export declare const appName: string;
 export declare const publicPath: string;
+export declare const defaultTheme: string;
 export declare const contextDir: string;
 export declare const buildDir: string;
 export declare const preloadEntrypoint: string;