@k8slens/extensions 6.3.0-git.9c64ddd59e.0 → 6.3.0-git.a83259b70a.0

package/dist/src/common/helm/helm-repo.d.ts

@@ -2,14 +2,14 @@
  * Copyright (c) OpenLens Authors. All rights reserved.
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
-export type HelmRepo = {
+export interface HelmRepo {
     name: string;
     url: string;
-    cacheFilePath?: string;
+    cacheFilePath: string;
     caFile?: string;
     certFile?: string;
     insecureSkipTlsVerify?: boolean;
     keyFile?: string;
     username?: string;
     password?: string;
-};
+}

package/dist/src/common/hotbars/migrations-token.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import type { MigrationDeclaration } from "../base-store/migrations.injectable";
+export declare const hotbarStoreMigrationInjectionToken: import("@ogre-tools/injectable").InjectionToken<MigrationDeclaration, void>;

package/dist/src/common/hotbars/store.d.ts

@@ -2,7 +2,8 @@
  * Copyright (c) OpenLens Authors. All rights reserved.
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
-import { BaseStore } from "../base-store";
+import type { BaseStoreDependencies } from "../base-store/base-store";
+import { BaseStore } from "../base-store/base-store";
 import type { CatalogEntity } from "../catalog";
 import type { Hotbar, CreateHotbarData, CreateHotbarOptions } from "./types";
 import type { GeneralEntity } from "../catalog-entities";
@@ -11,13 +12,12 @@ export interface HotbarStoreModel {
     hotbars: Hotbar[];
     activeHotbarId: string;
 }
-interface Dependencies {
+interface Dependencies extends BaseStoreDependencies {
     readonly catalogCatalogEntity: GeneralEntity;
     readonly logger: Logger;
 }
 export declare class HotbarStore extends BaseStore<HotbarStoreModel> {
-    private readonly dependencies;
-    readonly displayName = "HotbarStore";
+    protected readonly dependencies: Dependencies;
     hotbars: Hotbar[];
     private _activeHotbarId;
     constructor(dependencies: Dependencies);

package/dist/src/common/ipc/cluster.d.ts

@@ -5,10 +5,7 @@
 export declare const clusterActivateHandler = "cluster:activate";
 export declare const clusterSetFrameIdHandler = "cluster:set-frame-id";
 export declare const clusterVisibilityHandler = "cluster:visibility";
-export declare const clusterRefreshHandler = "cluster:refresh";
 export declare const clusterDisconnectHandler = "cluster:disconnect";
-export declare const clusterKubectlApplyAllHandler = "cluster:kubectl-apply-all";
-export declare const clusterKubectlDeleteAllHandler = "cluster:kubectl-delete-all";
 export declare const clusterStates = "cluster:states";
 /**
  * This channel is broadcast on whenever the cluster fails to list namespaces

package/dist/src/common/k8s/create-resource-stack.injectable.d.ts

@@ -0,0 +1,5 @@
+import type { KubernetesCluster } from "../catalog-entities";
+import type { ResourceApplyingStack } from "./resource-stack";
+export type CreateResourceStack = (cluster: KubernetesCluster, name: string) => ResourceApplyingStack;
+declare const createResourceStackInjectable: import("@ogre-tools/injectable").Injectable<CreateResourceStack, unknown, void>;
+export default createResourceStackInjectable;

package/dist/src/common/k8s/resource-stack.d.ts

@@ -1,8 +1,27 @@
 import type { KubernetesCluster } from "../catalog-entities";
+import type { AsyncResult } from "../utils/async-result";
+import type { Logger } from "../logger";
+import type { KubectlApplyAll, KubectlDeleteAll } from "../kube-helpers/channels";
+import type { ReadDirectory } from "../fs/read-directory.injectable";
+import type { JoinPaths } from "../path/join-paths.injectable";
+import type { ReadFile } from "../fs/read-file.injectable";
+export interface ResourceApplyingStack {
+    kubectlApplyFolder(folderPath: string, templateContext?: any, extraArgs?: string[]): Promise<string>;
+    kubectlDeleteFolder(folderPath: string, templateContext?: any, extraArgs?: string[]): Promise<string>;
+}
+export interface ResourceStackDependencies {
+    readonly logger: Logger;
+    kubectlApplyAll: KubectlApplyAll;
+    kubectlDeleteAll: KubectlDeleteAll;
+    readDirectory: ReadDirectory;
+    joinPaths: JoinPaths;
+    readFile: ReadFile;
+}
 export declare class ResourceStack {
-    protected cluster: KubernetesCluster;
-    protected name: string;
-    constructor(cluster: KubernetesCluster, name: string);
+    protected readonly dependencies: ResourceStackDependencies;
+    protected readonly cluster: KubernetesCluster;
+    protected readonly name: string;
+    constructor(dependencies: ResourceStackDependencies, cluster: KubernetesCluster, name: string);
     /**
      *
      * @param folderPath folder path that is searched for files defining kubernetes resources.
@@ -15,8 +34,8 @@ export declare class ResourceStack {
      * @param templateContext sets the template parameters that are to be applied to any templated kubernetes resources that are to be applied.
      */
     kubectlDeleteFolder(folderPath: string, templateContext?: any, extraArgs?: string[]): Promise<string>;
-    protected applyResources(resources: string[], extraArgs?: string[]): Promise<string>;
-    protected deleteResources(resources: string[], extraArgs?: string[]): Promise<string>;
-    protected appendKubectlArgs(kubectlArgs: string[]): string[];
+    protected applyResources(resources: string[], extraArgs?: string[]): Promise<AsyncResult<string, string>>;
+    protected deleteResources(resources: string[], extraArgs?: string[]): Promise<AsyncResult<string, string>>;
+    protected getAdditionalArgs(kubectlArgs: string[]): string[];
     protected renderTemplates(folderPath: string, templateContext: any): Promise<string[]>;
 }

package/dist/src/common/k8s-api/api-base-configs.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+export declare const apiBaseServerAddressInjectionToken: import("@ogre-tools/injectable").InjectionToken<string, void>;
+export declare const apiBaseHostHeaderInjectionToken: import("@ogre-tools/injectable").InjectionToken<string, void>;

package/dist/src/common/k8s-api/api-base.injectable.d.ts

@@ -0,0 +1,2 @@
+declare const apiBaseInjectable: import("@ogre-tools/injectable").Injectable<import("./json-api").JsonApi<import("./json-api").JsonApiData, import("./json-api").JsonApiParams<import("./json-api").JsonApiData>>, unknown, void>;
+export default apiBaseInjectable;

package/dist/src/common/k8s-api/api-manager/resource.store.d.ts

@@ -3,8 +3,9 @@
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
 import type { KubeApi } from "../kube-api";
+import type { KubeObjectStoreDependencies } from "../kube-object.store";
 import { KubeObjectStore } from "../kube-object.store";
 import type { KubeObject } from "../kube-object";
 export declare class CustomResourceStore<K extends KubeObject> extends KubeObjectStore<K, KubeApi<K>> {
-    constructor(api: KubeApi<K>);
+    constructor(deps: KubeObjectStoreDependencies, api: KubeApi<K>);
 }

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

@@ -2,7 +2,7 @@
  * Copyright (c) OpenLens Authors. All rights reserved.
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
-import type { KubeObjectMetadata, ObjectReference } from "../kube-object";
+import type { KubeObjectMetadata, KubeObjectScope, ObjectReference } from "../kube-object";
 import { KubeObject } from "../kube-object";
 import type { DerivedKubeApiOptions } from "../kube-api";
 import { KubeApi } from "../kube-api";
@@ -15,7 +15,7 @@ export interface EventSource {
     component?: string;
     host?: string;
 }
-export interface KubeEventData extends KubeJsonApiData<KubeObjectMetadata, void, void> {
+export interface KubeEventData extends KubeJsonApiData<KubeObjectMetadata<KubeObjectScope.Namespace>, void, void> {
     action?: string;
     count?: number;
     eventTime?: string;
@@ -31,7 +31,7 @@ export interface KubeEventData extends KubeJsonApiData<KubeObjectMetadata, void,
     source?: EventSource;
     type?: string;
 }
-export declare class KubeEvent extends KubeObject {
+export declare class KubeEvent extends KubeObject<KubeObjectMetadata<KubeObjectScope.Namespace>, void, void> {
     static kind: string;
     static namespaced: boolean;
     static apiBase: string;

package/dist/src/common/k8s-api/endpoints/helm-charts.api/request-readme.injectable.d.ts

@@ -1,3 +1,4 @@
-export type RequestHelmChartReadme = (repo: string, name: string, version?: string) => Promise<string>;
+import type { AsyncResult } from "../../../utils/async-result";
+export type RequestHelmChartReadme = (repo: string, name: string, version?: string) => Promise<AsyncResult<string>>;
 declare const requestHelmChartReadmeInjectable: import("@ogre-tools/injectable").Injectable<RequestHelmChartReadme, unknown, void>;
 export default requestHelmChartReadmeInjectable;

package/dist/src/common/k8s-api/endpoints/helm-charts.api/request-values.injectable.d.ts

@@ -1,3 +1,4 @@
-export type RequestHelmChartValues = (repo: string, name: string, version: string) => Promise<string>;
+import type { AsyncResult } from "../../../utils/async-result";
+export type RequestHelmChartValues = (repo: string, name: string, version: string) => Promise<AsyncResult<string>>;
 declare const requestHelmChartValuesInjectable: import("@ogre-tools/injectable").Injectable<RequestHelmChartValues, unknown, void>;
 export default requestHelmChartValuesInjectable;

package/dist/src/common/k8s-api/endpoints/helm-releases.api/request-update.injectable.d.ts

@@ -1,14 +1,10 @@
+import type { AsyncResult } from "../../../utils/async-result";
 interface HelmReleaseUpdatePayload {
     repo: string;
     chart: string;
     version: string;
     values: string;
 }
-export type RequestHelmReleaseUpdate = (name: string, namespace: string, payload: HelmReleaseUpdatePayload) => Promise<{
-    updateWasSuccessful: true;
-} | {
-    updateWasSuccessful: false;
-    error: unknown;
-}>;
+export type RequestHelmReleaseUpdate = (name: string, namespace: string, payload: HelmReleaseUpdatePayload) => Promise<AsyncResult<void, unknown>>;
 declare const requestHelmReleaseUpdateInjectable: import("@ogre-tools/injectable").Injectable<RequestHelmReleaseUpdate, unknown, void>;
 export default requestHelmReleaseUpdateInjectable;

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

@@ -37,7 +37,7 @@ export interface PersistentVolumeSpec {
     capacity?: Partial<Record<string, string>>;
     flexVolume?: {
         driver: string;
-        options: {
+        options?: {
             clusterNamespace: string;
             image: string;
             pool: string;

package/dist/src/common/k8s-api/endpoints/resource-applier.api/request-patch.injectable.d.ts

@@ -1,5 +1,6 @@
 import type { Patch } from "rfc6902";
+import type { AsyncResult } from "../../../utils/async-result";
 import type { KubeJsonApiData } from "../../kube-json-api";
-export type RequestKubeObjectPatch = (name: string, kind: string, ns: string | undefined, patch: Patch) => Promise<KubeJsonApiData>;
+export type RequestKubeObjectPatch = (name: string, kind: string, ns: string | undefined, patch: Patch) => Promise<AsyncResult<KubeJsonApiData, string>>;
 declare const requestKubeObjectPatchInjectable: import("@ogre-tools/injectable").Injectable<RequestKubeObjectPatch, unknown, void>;
 export default requestKubeObjectPatchInjectable;

package/dist/src/common/k8s-api/endpoints/resource-applier.api/request-update.injectable.d.ts

@@ -1,4 +1,5 @@
+import type { AsyncResult } from "../../../utils/async-result";
 import type { KubeJsonApiData } from "../../kube-json-api";
-export type RequestKubeObjectCreation = (resourceDescriptor: string) => Promise<KubeJsonApiData>;
+export type RequestKubeObjectCreation = (resourceDescriptor: string) => Promise<AsyncResult<KubeJsonApiData, string>>;
 declare const requestKubeObjectCreationInjectable: import("@ogre-tools/injectable").Injectable<RequestKubeObjectCreation, unknown, void>;
 export default requestKubeObjectCreationInjectable;

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

@@ -210,15 +210,16 @@ export declare class KubeApi<Object extends KubeObject = KubeObject, Data extend
     private computeApiBase;
     /**
      * This method differs from {@link formatUrlForNotListing} because this treats `""` as "all namespaces"
+     * NOTE: This is also useful for watching
      * @param namespace The namespace to list in or `""` for all namespaces
      */
-    formatUrlForListing(namespace: string): string;
+    formatUrlForListing(namespace: string | undefined, query?: Partial<KubeApiQueryParams>): string;
     /**
      * Format a URL pathname and query for acting upon a specific resource.
      */
-    formatUrlForNotListing(resource?: Partial<ResourceDescriptor>, query?: Partial<KubeApiQueryParams>): string;
+    formatUrlForNotListing({ name, namespace }?: Partial<ResourceDescriptor>): string;
     /**
-     * @deprecated use {@link formatUrlForNotListing} instead
+     * @deprecated use {@link formatUrlForNotListing} or {@link formatUrlForListing} instead
      */
     getUrl(resource?: Partial<ResourceDescriptor>, query?: Partial<KubeApiQueryParams>): string;
     protected normalizeQuery(query?: Partial<KubeApiQueryParams>): Partial<KubeApiQueryParams>;
@@ -234,6 +235,6 @@ export declare class KubeApi<Object extends KubeObject = KubeObject, Data extend
     patch(desc: ResourceDescriptor, data: PartialDeep<Object> | Patch, strategy: KubeApiPatchType): Promise<Object | null>;
     delete({ propagationPolicy, ...desc }: DeleteResourceDescriptor): Promise<KubeJsonApiData<import("./kube-object").KubeJsonApiObjectMetadata<import("./kube-object").KubeObjectScope>, unknown, unknown>>;
     getWatchUrl(namespace?: string, query?: KubeApiQueryParams): string;
-    watch(opts?: KubeApiWatchOptions<Object, Data>): () => void;
+    watch(opts?: KubeApiWatchOptions<Object, Data>): Disposer;
     protected modifyWatchEvent(event: IKubeWatchEvent<KubeJsonApiData<KubeObjectMetadata>>): void;
 }

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

@@ -2,7 +2,6 @@
  * Copyright (c) OpenLens Authors. All rights reserved.
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
-import type { ClusterContext } from "./cluster-context";
 import type { Disposer } from "../utils";
 import type { KubeJsonApiDataFor, KubeObject } from "./kube-object";
 import type { IKubeWatchEvent } from "./kube-watch-event";
@@ -12,6 +11,7 @@ import type { RequestInit } from "node-fetch";
 import type { Patch } from "rfc6902";
 import type { PartialDeep } from "type-fest";
 import AbortController from "abort-controller";
+import type { ClusterContext } from "../../renderer/cluster-frame-context/cluster-frame-context";
 export type OnLoadFailure = (error: unknown) => void;
 export interface KubeObjectStoreLoadingParams {
     namespaces: string[];
@@ -59,24 +59,16 @@ export interface KubeObjectStoreOptions {
 }
 export type KubeApiDataFrom<K extends KubeObject, A> = A extends KubeApi<K, infer D> ? D extends KubeJsonApiDataFor<K> ? D : never : never;
 export type JsonPatch = Patch;
+export interface KubeObjectStoreDependencies {
+    readonly context: ClusterContext;
+}
 export declare abstract class KubeObjectStore<K extends KubeObject = KubeObject, A extends KubeApi<K, D> = KubeApi<K, KubeJsonApiDataFor<K>>, D extends KubeJsonApiDataFor<K> = KubeApiDataFrom<K, A>> extends ItemStore<K> {
-    static readonly defaultContext: import("mobx").IObservableValue<ClusterContext | undefined>;
+    protected readonly dependencies: KubeObjectStoreDependencies;
     readonly api: A;
     readonly limit: number | undefined;
     readonly bufferSize: number;
-    private loadedNamespaces;
-    get contextReady(): Promise<void> & {
-        cancel(): void;
-    };
-    get namespacesReady(): Promise<void> & {
-        cancel(): void;
-    };
-    constructor(api: A, opts?: KubeObjectStoreOptions);
-    /**
-     * @deprecated Supply API instance through constructor
-     */
-    constructor();
-    get context(): ClusterContext | undefined;
+    private readonly loadedNamespaces;
+    constructor(dependencies: KubeObjectStoreDependencies, api: A, opts?: KubeObjectStoreOptions);
     get contextItems(): K[];
     getTotalCount(): number;
     get query(): KubeApiQueryParams;
@@ -118,7 +110,7 @@ export declare abstract class KubeObjectStore<K extends KubeObject = KubeObject,
     remove(item: K): Promise<void>;
     removeSelectedItems(): Promise<void>;
     removeItems(items: K[]): Promise<void>;
-    protected eventsBuffer: import("mobx").IObservableArray<IKubeWatchEvent<D>>;
+    protected readonly eventsBuffer: import("mobx").IObservableArray<IKubeWatchEvent<D>>;
     protected bindWatchEventsUpdater(delay?: number): void;
     subscribe({ onLoadFailure, abortController }?: KubeObjectStoreSubscribeParams): Disposer;
     private watchNamespace;

package/dist/src/common/kube-helpers/channels.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import type { Asyncify } from "type-fest";
+import type { RequestChannelHandler } from "../../main/utils/channel/channel-listeners/listener-tokens";
+import type { ClusterId } from "../cluster-types";
+import type { AsyncResult } from "../utils/async-result";
+import type { RequestChannel } from "../utils/channel/request-channel-listener-injection-token";
+export interface KubectlApplyAllArgs {
+    clusterId: ClusterId;
+    resources: string[];
+    extraArgs: string[];
+}
+export declare const kubectlApplyAllChannel: RequestChannel<KubectlApplyAllArgs, AsyncResult<string, string>>;
+export type KubectlApplyAll = Asyncify<RequestChannelHandler<typeof kubectlApplyAllChannel>>;
+export declare const kubectlApplyAllInjectionToken: import("@ogre-tools/injectable").InjectionToken<(req: KubectlApplyAllArgs) => Promise<AsyncResult<string, string>>, void>;
+export interface KubectlDeleteAllArgs {
+    clusterId: ClusterId;
+    resources: string[];
+    extraArgs: string[];
+}
+export declare const kubectlDeleteAllChannel: RequestChannel<KubectlDeleteAllArgs, AsyncResult<string, string>>;
+export type KubectlDeleteAll = Asyncify<RequestChannelHandler<typeof kubectlDeleteAllChannel>>;
+export declare const kubectlDeleteAllInjectionToken: import("@ogre-tools/injectable").InjectionToken<(req: KubectlDeleteAllArgs) => Promise<AsyncResult<string, string>>, void>;

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

@@ -12,5 +12,5 @@ export interface Logger {
 /**
  * @deprecated use `di.inject(loggerInjectable)` instead
  */
-declare const _default: Logger;
-export default _default;
+declare const logger: Logger;
+export default logger;

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

@@ -7,7 +7,7 @@ import type Url from "url-parse";
 import type { ExtensionsStore } from "../../extensions/extensions-store/extensions-store";
 import type { ExtensionLoader } from "../../extensions/extension-loader";
 import type { LensExtension } from "../../extensions/lens-extension";
-import type { RouteHandler } from "../../extensions/registries/protocol-handler";
+import type { RouteHandler } from "./registration";
 import type { Logger } from "../logger";
 export declare const ProtocolHandlerIpcPrefix = "protocol-handler";
 export declare const ProtocolHandlerInternal: string;

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

@@ -3,12 +3,20 @@
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
 export type KubeResource = "namespaces" | "nodes" | "events" | "resourcequotas" | "services" | "limitranges" | "leases" | "secrets" | "configmaps" | "ingresses" | "networkpolicies" | "persistentvolumeclaims" | "persistentvolumes" | "storageclasses" | "pods" | "daemonsets" | "deployments" | "statefulsets" | "replicasets" | "jobs" | "cronjobs" | "endpoints" | "customresourcedefinitions" | "horizontalpodautoscalers" | "podsecuritypolicies" | "poddisruptionbudgets" | "priorityclasses" | "runtimeclasses" | "roles" | "clusterroles" | "rolebindings" | "clusterrolebindings" | "serviceaccounts";
-export interface KubeApiResource extends KubeApiResourceData {
-    apiName: KubeResource;
+export interface KubeApiResource {
+    kind: string;
+    group: string;
+    apiName: string;
+    namespaced: boolean;
+}
+export interface KubeApiResourceDescriptor {
+    apiName: string;
+    group: string;
 }
+export declare const formatKubeApiResource: (res: KubeApiResourceDescriptor) => string;
 export interface KubeApiResourceData {
     kind: string;
-    group?: string;
+    group: string;
+    namespaced: boolean;
 }
 export declare const apiResourceRecord: Record<KubeResource, KubeApiResourceData>;
-export declare const apiResources: KubeApiResource[];

package/dist/src/common/runnable/run-many-for.d.ts

@@ -3,12 +3,14 @@
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
 import type { DiContainerForInjection, InjectionToken } from "@ogre-tools/injectable";
+import type { SingleOrMany } from "../utils";
+import type { Asyncify } from "type-fest";
 export interface Runnable<TParameter = void> {
     id: string;
     run: Run<TParameter>;
-    runAfter?: Runnable<TParameter>;
+    runAfter?: SingleOrMany<Runnable<TParameter>>;
 }
 type Run<Param> = (parameter: Param) => Promise<void> | void;
-export type RunMany = <Param>(injectionToken: InjectionToken<Runnable<Param>, void>) => Run<Param>;
+export type RunMany = <Param>(injectionToken: InjectionToken<Runnable<Param>, void>) => Asyncify<Run<Param>>;
 export declare function runManyFor(di: DiContainerForInjection): RunMany;
 export {};

package/dist/src/common/user-store/current-timezone.global-override-for-injectable.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+declare const _default: {
+    injectable: import("@ogre-tools/injectable").Injectable<string, unknown, void>;
+    overridingInstantiate: import("@ogre-tools/injectable").Instantiate<string, void>;
+};
+export default _default;

package/dist/src/common/user-store/current-timezone.injectable.d.ts

@@ -0,0 +1,2 @@
+declare const currentTimezoneInjectable: import("@ogre-tools/injectable").Injectable<string, unknown, void>;
+export default currentTimezoneInjectable;

package/dist/src/common/user-store/https-proxy.injectable.d.ts

@@ -0,0 +1,2 @@
+declare const httpsProxyConfigurationInjectable: import("@ogre-tools/injectable").Injectable<import("mobx").IComputedValue<string | undefined>, unknown, void>;
+export default httpsProxyConfigurationInjectable;

package/dist/src/common/user-store/lens-color-theme.injectable.d.ts

@@ -0,0 +1,8 @@
+export type LensColorThemePreference = {
+    useSystemTheme: true;
+} | {
+    useSystemTheme: false;
+    lensThemeId: string;
+};
+declare const lensColorThemePreferenceInjectable: import("@ogre-tools/injectable").Injectable<import("mobx").IComputedValue<LensColorThemePreference>, unknown, void>;
+export default lensColorThemePreferenceInjectable;

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

@@ -0,0 +1,6 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import type { MigrationDeclaration } from "../base-store/migrations.injectable";
+export declare const userStoreMigrationInjectionToken: import("@ogre-tools/injectable").InjectionToken<MigrationDeclaration, void>;

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

@@ -4,7 +4,7 @@
  */
 /// <reference types="node" />
 import type { editor } from "monaco-editor";
-import type { ObservableMap } from "mobx";
+import type { PreferenceDescriptors } from "./preference-descriptors.injectable";
 export interface KubeconfigSyncEntry extends KubeconfigSyncValue {
     filePath: string;
 }
@@ -25,7 +25,7 @@ export interface PreferenceDescription<T, R = T> {
     fromStore(val: T | undefined): R;
     toStore(val: R): T | undefined;
 }
-export declare const defaultLocaleTimezone = "UTC";
+export declare const getPreferenceDescriptor: <T, R = T>(desc: PreferenceDescription<T, R>) => PreferenceDescription<T, R>;
 export interface DownloadMirror {
     url: string;
     label: string;
@@ -43,34 +43,14 @@ export type ExtensionRegistry = {
 };
 export declare const defaultExtensionRegistryUrlLocation = "default";
 export declare const defaultExtensionRegistryUrl = "https://registry.npmjs.org";
-type PreferencesModelType<field extends keyof typeof DESCRIPTORS> = typeof DESCRIPTORS[field] extends PreferenceDescription<infer T, any> ? T : never;
-type UserStoreModelType<field extends keyof typeof DESCRIPTORS> = typeof DESCRIPTORS[field] extends PreferenceDescription<any, infer T> ? T : never;
+type PreferencesModelType<field extends keyof PreferenceDescriptors> = PreferenceDescriptors[field] extends PreferenceDescription<infer T, any> ? T : never;
+type UserStoreModelType<field extends keyof PreferenceDescriptors> = PreferenceDescriptors[field] extends PreferenceDescription<any, infer T> ? T : never;
 export type UserStoreFlatModel = {
-    [field in keyof typeof DESCRIPTORS]: UserStoreModelType<field>;
+    [field in keyof PreferenceDescriptors]: UserStoreModelType<field>;
 };
 export type UserPreferencesModel = {
-    [field in keyof typeof DESCRIPTORS]: PreferencesModelType<field>;
+    [field in keyof PreferenceDescriptors]: PreferencesModelType<field>;
 } & {
     updateChannel: string;
 };
-export declare const DESCRIPTORS: {
-    httpsProxy: PreferenceDescription<string | undefined, string | undefined>;
-    shell: PreferenceDescription<string | undefined, string | undefined>;
-    colorTheme: PreferenceDescription<string, string>;
-    terminalTheme: PreferenceDescription<string, string>;
-    localeTimezone: PreferenceDescription<string, string>;
-    allowUntrustedCAs: PreferenceDescription<boolean, boolean>;
-    allowErrorReporting: PreferenceDescription<boolean, boolean>;
-    downloadMirror: PreferenceDescription<string, string>;
-    downloadKubectlBinaries: PreferenceDescription<boolean, boolean>;
-    downloadBinariesPath: PreferenceDescription<string | undefined, string | undefined>;
-    kubectlBinariesPath: PreferenceDescription<string | undefined, string | undefined>;
-    openAtLogin: PreferenceDescription<boolean, boolean>;
-    hiddenTableColumns: PreferenceDescription<[string, string[]][], Map<string, Set<string>>>;
-    syncKubeconfigEntries: PreferenceDescription<KubeconfigSyncEntry[], ObservableMap<string, KubeconfigSyncValue>>;
-    editorConfiguration: PreferenceDescription<Partial<Required<BaseEditorConfiguration>> | undefined, Required<BaseEditorConfiguration>>;
-    terminalCopyOnSelect: PreferenceDescription<boolean, boolean>;
-    terminalConfig: PreferenceDescription<TerminalConfig, TerminalConfig>;
-    extensionRegistryUrl: PreferenceDescription<ExtensionRegistry, ExtensionRegistry>;
-};
 export {};

package/dist/src/common/user-store/terminal-theme.injectable.d.ts

@@ -0,0 +1,8 @@
+export type TerminalThemePreference = {
+    matchLensTheme: true;
+} | {
+    matchLensTheme: false;
+    themeId: string;
+};
+declare const terminalThemePreferenceInjectable: import("@ogre-tools/injectable").Injectable<import("mobx").IComputedValue<TerminalThemePreference>, unknown, void>;
+export default terminalThemePreferenceInjectable;

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

@@ -2,24 +2,23 @@
  * Copyright (c) OpenLens Authors. All rights reserved.
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
-import { BaseStore } from "../base-store";
-import { DESCRIPTORS } from "./preferences-helpers";
+import type { BaseStoreDependencies } from "../base-store/base-store";
+import { BaseStore } from "../base-store/base-store";
 import type { UserPreferencesModel, StoreType } from "./preferences-helpers";
 import type { EmitAppEvent } from "../app-event-bus/emit-event.injectable";
 import type { SelectedUpdateChannel } from "../../features/application-update/common/selected-update-channel/selected-update-channel.injectable";
+import type { PreferenceDescriptors } from "./preference-descriptors.injectable";
 export interface UserStoreModel {
-    lastSeenAppVersion: string;
     preferences: UserPreferencesModel;
 }
-interface Dependencies {
+interface Dependencies extends BaseStoreDependencies {
     readonly selectedUpdateChannel: SelectedUpdateChannel;
+    readonly preferenceDescriptors: PreferenceDescriptors;
     emitAppEvent: EmitAppEvent;
 }
 export declare class UserStore extends BaseStore<UserStoreModel> {
-    private readonly dependencies;
-    readonly displayName = "UserStore";
+    protected readonly dependencies: Dependencies;
     constructor(dependencies: Dependencies);
-    lastSeenAppVersion: string;
     /**
      * @deprecated No longer used
      */
@@ -28,41 +27,40 @@ export declare class UserStore extends BaseStore<UserStoreModel> {
      * @deprecated No longer used
      */
     newContexts: import("mobx").ObservableSet<string>;
-    allowErrorReporting: StoreType<typeof DESCRIPTORS["allowErrorReporting"]>;
-    allowUntrustedCAs: StoreType<typeof DESCRIPTORS["allowUntrustedCAs"]>;
-    colorTheme: StoreType<typeof DESCRIPTORS["colorTheme"]>;
-    terminalTheme: StoreType<typeof DESCRIPTORS["terminalTheme"]>;
-    localeTimezone: StoreType<typeof DESCRIPTORS["localeTimezone"]>;
-    downloadMirror: StoreType<typeof DESCRIPTORS["downloadMirror"]>;
-    httpsProxy: StoreType<typeof DESCRIPTORS["httpsProxy"]>;
-    shell: StoreType<typeof DESCRIPTORS["shell"]>;
-    downloadBinariesPath: StoreType<typeof DESCRIPTORS["downloadBinariesPath"]>;
-    kubectlBinariesPath: StoreType<typeof DESCRIPTORS["kubectlBinariesPath"]>;
-    terminalCopyOnSelect: StoreType<typeof DESCRIPTORS["terminalCopyOnSelect"]>;
-    terminalConfig: StoreType<typeof DESCRIPTORS["terminalConfig"]>;
-    extensionRegistryUrl: StoreType<typeof DESCRIPTORS["extensionRegistryUrl"]>;
+    allowErrorReporting: StoreType<PreferenceDescriptors["allowErrorReporting"]>;
+    allowUntrustedCAs: StoreType<PreferenceDescriptors["allowUntrustedCAs"]>;
+    colorTheme: StoreType<PreferenceDescriptors["colorTheme"]>;
+    terminalTheme: StoreType<PreferenceDescriptors["terminalTheme"]>;
+    localeTimezone: StoreType<PreferenceDescriptors["localeTimezone"]>;
+    downloadMirror: StoreType<PreferenceDescriptors["downloadMirror"]>;
+    httpsProxy: StoreType<PreferenceDescriptors["httpsProxy"]>;
+    shell: StoreType<PreferenceDescriptors["shell"]>;
+    downloadBinariesPath: StoreType<PreferenceDescriptors["downloadBinariesPath"]>;
+    kubectlBinariesPath: StoreType<PreferenceDescriptors["kubectlBinariesPath"]>;
+    terminalCopyOnSelect: StoreType<PreferenceDescriptors["terminalCopyOnSelect"]>;
+    terminalConfig: StoreType<PreferenceDescriptors["terminalConfig"]>;
+    extensionRegistryUrl: StoreType<PreferenceDescriptors["extensionRegistryUrl"]>;
     /**
      * Download kubectl binaries matching cluster version
      */
-    downloadKubectlBinaries: StoreType<typeof DESCRIPTORS["downloadKubectlBinaries"]>;
+    downloadKubectlBinaries: StoreType<PreferenceDescriptors["downloadKubectlBinaries"]>;
     /**
      * Whether the application should open itself at login.
      */
-    openAtLogin: StoreType<typeof DESCRIPTORS["openAtLogin"]>;
+    openAtLogin: StoreType<PreferenceDescriptors["openAtLogin"]>;
     /**
      * The column IDs under each configurable table ID that have been configured
      * to not be shown
      */
-    hiddenTableColumns: StoreType<typeof DESCRIPTORS["hiddenTableColumns"]>;
+    hiddenTableColumns: StoreType<PreferenceDescriptors["hiddenTableColumns"]>;
     /**
      * Monaco editor configs
      */
-    editorConfiguration: StoreType<typeof DESCRIPTORS["editorConfiguration"]>;
+    editorConfiguration: StoreType<PreferenceDescriptors["editorConfiguration"]>;
     /**
      * The set of file/folder paths to be synced
      */
-    syncKubeconfigEntries: StoreType<typeof DESCRIPTORS["syncKubeconfigEntries"]>;
-    startMainReactions(): void;
+    syncKubeconfigEntries: StoreType<PreferenceDescriptors["syncKubeconfigEntries"]>;
     /**
      * Checks if a column (by ID) for a table (by ID) is configured to be hidden
      * @param tableId The ID of the table to be checked against
@@ -75,7 +73,7 @@ export declare class UserStore extends BaseStore<UserStoreModel> {
      */
     toggleTableColumnVisibility(tableId: string, columnId: string): void;
     resetTheme(): void;
-    protected fromStore({ lastSeenAppVersion, preferences }?: Partial<UserStoreModel>): void;
+    protected fromStore({ preferences }?: Partial<UserStoreModel>): void;
     toJSON(): UserStoreModel;
 }
 export {};

package/dist/src/common/utils/binary-name.injectable.d.ts

@@ -0,0 +1,2 @@
+declare const binaryNameInjectable: import("@ogre-tools/injectable").Injectable<string, unknown, string>;
+export default binaryNameInjectable;

package/dist/src/common/utils/bundled-binary-path.injectable.d.ts

@@ -0,0 +1,2 @@
+declare const bundledBinaryPathInjectable: import("@ogre-tools/injectable").Injectable<string, unknown, string>;
+export default bundledBinaryPathInjectable;