@k8slens/extensions 5.3.0-git.2d801478e1.0 → 5.3.0-git.30170163a6.0

package/__mocks__/electron.ts

@@ -26,11 +26,6 @@ export default {
     getLocale: jest.fn().mockRejectedValue("en"),
     getPath: jest.fn(() => "tmp"),
   },
-  remote: {
-    app: {
-      getPath: jest.fn()
-    }
-  },
   dialog: jest.fn(),
   ipcRenderer: {
     on: jest.fn()

package/dist/integration/helpers/utils.d.ts

@@ -1,7 +1,7 @@
 /// <reference types="node" />
 /// <reference types="jest" />
 import { ElectronApplication, Frame, Page } from "playwright";
-export declare const AppPaths: Partial<Record<NodeJS.Platform, string>>;
+export declare const appPaths: Partial<Record<NodeJS.Platform, string>>;
 export declare function itIf(condition: boolean): jest.It;
 export declare function describeIf(condition: boolean): jest.Describe;
 export declare function start(): Promise<{

package/dist/src/common/app-paths.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Copyright (c) 2021 OpenLens Authors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * 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 { app } from "electron";
+export declare type PathName = Parameters<typeof app["getPath"]>[0];
+export declare class AppPaths {
+    private static paths;
+    private static readonly ipcChannel;
+    /**
+     * Initializes the local copy of the paths from electron.
+     */
+    static init(): Promise<void>;
+    private static initMain;
+    private static initRenderer;
+    /**
+     * An alternative to `app.getPath()` for use in renderer and common.
+     * This function throws if called before initialization.
+     * @param name The name of the path field
+     */
+    static get(name: PathName): string;
+    /**
+     * An async version of `AppPaths.get()` which waits for `AppPaths.init()` to
+     * be called before returning
+     */
+    static getAsync(name: PathName): Promise<string>;
+}

package/dist/src/common/catalog/catalog-entity.d.ts

@@ -127,7 +127,10 @@ export interface CatalogEntitySettingsMenu {
     };
 }
 export interface CatalogEntityContextMenuContext {
-    navigate: (url: string) => void;
+    /**
+     * Navigate to the specified pathname
+     */
+    navigate: (pathname: string) => void;
     menuItems: CatalogEntityContextMenu[];
 }
 export interface CatalogEntitySettingsContext {

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

@@ -27,7 +27,6 @@ export interface ClusterStoreModel {
 export declare class ClusterStore extends BaseStore<ClusterStoreModel> {
     private static StateChannel;
     clusters: import("mobx").ObservableMap<string, Cluster>;
-    removedClusters: import("mobx").ObservableMap<string, Cluster>;
     protected disposer: import("./utils").ExtendableDisposer;
     constructor();
     loadInitialOnRenderer(): Promise<void>;

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

@@ -55,4 +55,9 @@ export declare class HotbarStore extends BaseStore<HotbarStoreModel> {
     restackItems(from: number, to: number): void;
     switchToPrevious(): void;
     switchToNext(): void;
+    /**
+     * Checks if entity already pinned to hotbar
+     * @returns boolean
+     */
+    isAddedToActive(entity: CatalogEntity): boolean;
 }

package/dist/src/common/hotbar-types.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 type { Tuple } from "./utils";
+import { Tuple } from "./utils";
 export interface HotbarItem {
     entity: {
         uid: string;

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

@@ -43,6 +43,14 @@ export interface NodeTaint {
     timeAdded: string;
 }
 export declare function formatNodeTaint(taint: NodeTaint): string;
+export interface NodeCondition {
+    type: string;
+    status: string;
+    lastHeartbeatTime?: string;
+    lastTransitionTime?: string;
+    reason?: string;
+    message?: string;
+}
 export interface Node {
     spec: {
         podCIDR?: string;
@@ -72,14 +80,7 @@ export interface Node {
             memory: string;
             pods: string;
         };
-        conditions?: {
-            type: string;
-            status: string;
-            lastHeartbeatTime?: string;
-            lastTransitionTime?: string;
-            reason?: string;
-            message?: string;
-        }[];
+        conditions?: NodeCondition[];
         addresses?: {
             type: string;
             address: string;
@@ -117,35 +118,18 @@ export declare class Node extends KubeObject {
     static namespaced: boolean;
     static apiBase: string;
     constructor(data: KubeJsonApiData);
+    /**
+     * Returns the concatination of all current condition types which have a status
+     * of `"True"`
+     */
     getNodeConditionText(): string;
     getTaints(): NodeTaint[];
     getRoleLabels(): string;
     getCpuCapacity(): number;
     getMemoryCapacity(): number;
-    getConditions(): {
-        type: string;
-        status: string;
-        lastHeartbeatTime?: string;
-        lastTransitionTime?: string;
-        reason?: string;
-        message?: string;
-    }[];
-    getActiveConditions(): {
-        type: string;
-        status: string;
-        lastHeartbeatTime?: string;
-        lastTransitionTime?: string;
-        reason?: string;
-        message?: string;
-    }[];
-    getWarningConditions(): {
-        type: string;
-        status: string;
-        lastHeartbeatTime?: string;
-        lastTransitionTime?: string;
-        reason?: string;
-        message?: string;
-    }[];
+    getConditions(): NodeCondition[];
+    getActiveConditions(): NodeCondition[];
+    getWarningConditions(): NodeCondition[];
     getKubeletVersion(): string;
     getOperatingSystem(): string;
     isUnschedulable(): boolean;

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

@@ -57,7 +57,7 @@ export declare enum PodStatus {
     SUCCEEDED = "Succeeded",
     EVICTED = "Evicted"
 }
-export interface IPodContainer {
+export interface IPodContainer extends Partial<Record<PodContainerProbe, IContainerProbe>> {
     name: string;
     image: string;
     command?: string[];
@@ -108,15 +108,16 @@ export interface IPodContainer {
         readOnly: boolean;
         mountPath: string;
     }[];
-    livenessProbe?: IContainerProbe;
-    readinessProbe?: IContainerProbe;
-    startupProbe?: IContainerProbe;
     imagePullPolicy: string;
 }
+export declare type PodContainerProbe = "livenessProbe" | "readinessProbe" | "startupProbe";
 interface IContainerProbe {
     httpGet?: {
         path?: string;
-        port: number;
+        /**
+         * either a port number or an IANA_SVC_NAME string referring to a port defined in the container
+         */
+        port: number | string;
         scheme: string;
         host?: string;
     };
@@ -303,7 +304,7 @@ export declare class Pod extends WorkloadKubeObject {
     getLivenessProbe(container: IPodContainer): string[];
     getReadinessProbe(container: IPodContainer): string[];
     getStartupProbe(container: IPodContainer): string[];
-    getProbe(probeData: IContainerProbe): string[];
+    private getProbe;
     getNodeName(): string;
     getSelectedNodeOs(): string | undefined;
     getIPs(): string[];

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

@@ -35,18 +35,17 @@ export interface ISecretRef {
     key?: string;
     name: string;
 }
-export interface Secret {
+export interface SecretData extends KubeJsonApiData {
     type: SecretType;
-    data: {
-        [prop: string]: string;
-        token?: string;
-    };
+    data?: Record<string, string>;
 }
 export declare class Secret extends KubeObject {
     static kind: string;
     static namespaced: boolean;
     static apiBase: string;
-    constructor(data: KubeJsonApiData);
+    type: SecretType;
+    data: Record<string, string>;
+    constructor(data: SecretData);
     getKeys(): string[];
     getToken(): string;
 }

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

@@ -38,7 +38,7 @@ export interface Service {
         clusterIP: string;
         clusterIPs?: string[];
         externalTrafficPolicy?: string;
-        externalName: string;
+        externalName?: string;
         loadBalancerIP?: string;
         loadBalancerSourceRanges?: string[];
         sessionAffinity: string;

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

@@ -48,6 +48,7 @@ export interface JsonApiConfig {
     apiBase: string;
     serverAddress: string;
     debug?: boolean;
+    getRequestOptions?: () => Promise<RequestInit>;
 }
 export declare class JsonApi<D = JsonApiData, P extends JsonApiParams = JsonApiParams> {
     readonly config: JsonApiConfig;
@@ -57,6 +58,7 @@ export declare class JsonApi<D = JsonApiData, P extends JsonApiParams = JsonApiP
     constructor(config: JsonApiConfig, reqInit?: RequestInit);
     onData: EventEmitter<[D, Response]>;
     onError: EventEmitter<[JsonApiErrorParsed, Response]>;
+    private getRequestOptions;
     get<T = D>(path: string, params?: P, reqInit?: RequestInit): Promise<T>;
     getResponse(path: string, params?: P, init?: RequestInit): Promise<Response>;
     post<T = D>(path: string, params?: P, reqInit?: RequestInit): Promise<T>;

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

@@ -86,7 +86,7 @@ export interface IRemoteKubeApiConfig {
         skipTLSVerify?: boolean;
     };
     user: {
-        token?: string;
+        token?: string | (() => Promise<string>);
         clientCertificateData?: string;
         clientKeyData?: string;
     };

package/dist/src/common/routes/port-forwards.d.ts

@@ -21,5 +21,6 @@
 import type { RouteProps } from "react-router";
 export declare const portForwardsRoute: RouteProps;
 export interface PortForwardsRouteParams {
+    forwardport?: string;
 }
 export declare const portForwardsURL: ({ params, query, fragment }?: import("../utils/buildUrl").URLParams<PortForwardsRouteParams, {}>) => string;

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

@@ -18,6 +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.
  */
+/// <reference types="node" />
 import { ObservableToggleSet } from "../utils";
 import type { monaco } from "react-monaco-editor";
 export interface KubeconfigSyncEntry extends KubeconfigSyncValue {
@@ -35,6 +36,13 @@ interface PreferenceDescription<T, R = T> {
     fromStore(val: T | undefined): R;
     toStore(val: R): T | undefined;
 }
+export interface DownloadMirror {
+    url: string;
+    label: string;
+    platforms: Set<NodeJS.Platform>;
+}
+export declare const defaultPackageMirror = "default";
+export declare const packageMirrors: Map<string, DownloadMirror>;
 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 = {

package/dist/src/common/utils/__tests__/tuple.test.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Copyright (c) 2021 OpenLens Authors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * 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.
+ */
+export {};

package/dist/src/common/utils/{getPath.d.ts → array.d.ts}

@@ -18,10 +18,9 @@
  * 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 { app } from "electron";
 /**
- * calls getPath either on app or on the remote's app
- *
- * @deprecated Use a different method for accessing the getPath function
+ * A inference typed version of `Array(length).fill(value)`
+ * @param length The number of entries
+ * @param value The value of each of the indices
  */
-export declare function getPath(name: Parameters<typeof app["getPath"]>[0]): string;
+export declare function filled<T>(length: number, value: T): T[];

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

@@ -28,19 +28,21 @@ export * from "./base64";
 export * from "./camelCase";
 export * from "./cloneJson";
 export * from "./cluster-id-url-parsing";
+export * from "./convertCpu";
+export * from "./convertMemory";
 export * from "./debouncePromise";
 export * from "./defineGlobal";
 export * from "./delay";
 export * from "./disposer";
 export * from "./downloadFile";
-export * from "./formatDuration";
 export * from "./escapeRegExp";
 export * from "./extended-map";
-export * from "./getPath";
+export * from "./formatDuration";
 export * from "./getRandId";
 export * from "./hash-set";
 export * from "./local-kubeconfig";
 export * from "./n-fircate";
+export * from "./objects";
 export * from "./openExternal";
 export * from "./paths";
 export * from "./reject-promise";
@@ -52,7 +54,7 @@ export * from "./toggle-set";
 export * from "./toJS";
 export * from "./type-narrowing";
 export * from "./types";
-export * from "./convertMemory";
-export * from "./convertCpu";
 import * as iter from "./iter";
-export { iter };
+import * as array from "./array";
+import * as tuple from "./tuple";
+export { iter, array, tuple, };

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

@@ -23,54 +23,54 @@ export declare type Falsey = false | 0 | "" | null | undefined;
  * Create a new type safe empty Iterable
  * @returns An `Iterable` that yields 0 items
  */
-export declare function newEmpty<T>(): Iterable<T>;
+export declare function newEmpty<T>(): IterableIterator<T>;
 /**
  * Creates a new `Iterable` that yields at most n items from src.
  * Does not modify `src` which can be used later.
  * @param src An initial iterator
  * @param n The maximum number of elements to take from src. Yields up to the floor of `n` and 0 items if n < 0
  */
-export declare function take<T>(src: Iterable<T>, n: number): Iterable<T>;
+export declare function take<T>(src: Iterable<T>, n: number): IterableIterator<T>;
 /**
  * Creates a new iterator that iterates (lazily) over its input and yields the
  * result of `fn` for each item.
  * @param src A type that can be iterated over
  * @param fn The function that is called for each value
  */
-export declare function map<T, U>(src: Iterable<T>, fn: (from: T) => U): Iterable<U>;
+export declare function map<T, U>(src: Iterable<T>, fn: (from: T) => U): IterableIterator<U>;
 /**
  * The single layer flattening of an iterator, discarding `Falsey` values.
  * @param src A type that can be iterated over
  * @param fn The function that returns either an iterable over items that should be filtered out or a `Falsey` value indicating that it should be ignored
  */
-export declare function filterFlatMap<T, U>(src: Iterable<T>, fn: (from: T) => Iterable<U | Falsey> | Falsey): Iterable<U>;
+export declare function filterFlatMap<T, U>(src: Iterable<T>, fn: (from: T) => Iterable<U | Falsey> | Falsey): IterableIterator<U>;
 /**
  * Returns a new iterator that yields the items that each call to `fn` would produce
  * @param src A type that can be iterated over
  * @param fn A function that returns an iterator
  */
-export declare function flatMap<T, U>(src: Iterable<T>, fn: (from: T) => Iterable<U>): Iterable<U>;
+export declare function flatMap<T, U>(src: Iterable<T>, fn: (from: T) => Iterable<U>): IterableIterator<U>;
 /**
  * Creates a new iterator that iterates (lazily) over its input and yields the
  * items that return a `truthy` value from `fn`.
  * @param src A type that can be iterated over
  * @param fn The function that is called for each value
  */
-export declare function filter<T>(src: Iterable<T>, fn: (from: T) => any): Iterable<T>;
+export declare function filter<T>(src: Iterable<T>, fn: (from: T) => any): IterableIterator<T>;
 /**
  * Creates a new iterator that iterates (lazily) over its input and yields the
  * result of `fn` when it is `truthy`
  * @param src A type that can be iterated over
  * @param fn The function that is called for each value
  */
-export declare function filterMap<T, U>(src: Iterable<T>, fn: (from: T) => U | Falsey): Iterable<U>;
+export declare function filterMap<T, U>(src: Iterable<T>, fn: (from: T) => U | Falsey): IterableIterator<U>;
 /**
  * Creates a new iterator that iterates (lazily) over its input and yields the
  * result of `fn` when it is not null or undefined
  * @param src A type that can be iterated over
  * @param fn The function that is called for each value
  */
-export declare function filterMapStrict<T, U>(src: Iterable<T>, fn: (from: T) => U | null | undefined): Iterable<U>;
+export declare function filterMapStrict<T, U>(src: Iterable<T>, fn: (from: T) => U | null | undefined): IterableIterator<U>;
 /**
  * Iterate through `src` until `match` returns a truthy value
  * @param src A type that can be iterated over
@@ -85,4 +85,18 @@ export declare function find<T>(src: Iterable<T>, match: (i: T) => any): T | und
  * @param reducer A function for producing the next item from an accumilation and the current item
  * @param initial The initial value for the iteration
  */
-export declare function reduce<T, R>(src: Iterable<T>, reducer: (acc: Iterable<R>, cur: T) => Iterable<R>, initial: Iterable<R>): Iterable<R>;
+export declare function reduce<T, R extends Iterable<any>>(src: Iterable<T>, reducer: (acc: R, cur: T) => R, initial: R): R;
+/**
+ * A convenience function for reducing over an iterator of strings and concatenating them together
+ * @param src The value to iterate over
+ * @param connector The string value to intersperse between the yielded values
+ * @returns The concatenated entries of `src` interspersed with copies of `connector`
+ */
+export declare function join(src: Iterable<string>, connector?: string): string;
+/**
+ * Iterate through `src` and return `true` if `fn` returns a thruthy value for every yielded value.
+ * Otherwise, return `false`. This function short circuits.
+ * @param src The type to be iterated over
+ * @param fn A function to check each iteration
+ */
+export declare function every<T>(src: Iterable<T>, fn: (val: T) => any): boolean;

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

@@ -0,0 +1,27 @@
+/**
+ * Copyright (c) 2021 OpenLens Authors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * 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.
+ */
+/**
+ * A better typed version of `Object.fromEntries` where the keys are known to
+ * be a specific subset
+ */
+export declare function fromEntries<T, Key extends string>(entries: Iterable<readonly [Key, T]>): {
+    [k in Key]: T;
+};

package/dist/src/common/utils/sort-compare.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Copyright (c) 2021 OpenLens Authors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * 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 { SemVer } from "semver";
+import type { RawHelmChart } from "../k8s-api/endpoints/helm-charts.api";
+export declare enum Ordering {
+    LESS = -1,
+    EQUAL = 0,
+    GREATER = 1
+}
+/**
+ * This function switches the direction of `ordering` if `direction` is `"desc"`
+ * @param ordering The original ordering (assumed to be an "asc" ordering)
+ * @param direction The new desired direction
+ */
+export declare function rectifyOrdering(ordering: Ordering, direction: "asc" | "desc"): Ordering;
+/**
+ * An ascending sorting function
+ * @param left An item from an array
+ * @param right An item from an array
+ * @returns The relative ordering in an ascending manner.
+ * - Less if left < right
+ * - Equal if left == right
+ * - Greater if left > right
+ */
+export declare function sortCompare<T>(left: T, right: T): Ordering;
+interface ChartVersion {
+    version: string;
+    __version?: SemVer;
+}
+export declare function sortCompareChartVersions(left: ChartVersion, right: ChartVersion): Ordering;
+export declare function sortCharts(charts: RawHelmChart[]): RawHelmChart[];
+export {};

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

@@ -0,0 +1,40 @@
+/**
+ * Copyright (c) 2021 OpenLens Authors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * 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.
+ */
+/**
+ * A strict N-tuple of type T
+ */
+export declare type Tuple<T, N extends number> = N extends N ? number extends N ? T[] : _TupleOf<T, N, []> : never;
+declare type _TupleOf<T, N extends number, R extends unknown[]> = R["length"] extends N ? R : _TupleOf<T, N, [T, ...R]>;
+/**
+ * Iterates over `sources` yielding full tuples until one of the tuple arrays
+ * is empty. Then it returns a tuple with the rest of each of tuples
+ * @param sources The source arrays
+ * @yields A tuple of the next element from each of the sources
+ * @returns The tuple of all the sources as soon as at least one of the sources is exausted
+ */
+export declare function zip<T, N extends number>(...sources: Tuple<T[], N>): Iterator<Tuple<T, N>, Tuple<T[], N>>;
+/**
+ * Returns a `length` tuple filled with copies of `value`
+ * @param length The size of the tuple
+ * @param value The value for each of the tuple entries
+ */
+export declare function filled<T, L extends number>(length: L, value: T): Tuple<T, L>;
+export {};