@k8slens/extensions 5.3.1-git.637f26ae1e.0 → 5.3.1-git.66d0a354b1.0

package/dist/src/extensions/{extension-discovery.d.ts → extension-discovery/extension-discovery.d.ts}

@@ -20,8 +20,21 @@
  */
 /// <reference types="node" />
 import { EventEmitter } from "events";
-import { Singleton } from "../common/utils";
-import type { LensExtensionId, LensExtensionManifest } from "./lens-extension";
+import type { ExtensionsStore } from "../extensions-store/extensions-store";
+import type { ExtensionLoader } from "../extension-loader";
+import type { LensExtensionId, LensExtensionManifest } from "../lens-extension";
+import type { ExtensionInstallationStateStore } from "../extension-installation-state-store/extension-installation-state-store";
+import type { PackageJson } from "type-fest";
+interface Dependencies {
+    extensionLoader: ExtensionLoader;
+    extensionsStore: ExtensionsStore;
+    extensionInstallationStateStore: ExtensionInstallationStateStore;
+    isCompatibleBundledExtension: (manifest: LensExtensionManifest) => boolean;
+    isCompatibleExtension: (manifest: LensExtensionManifest) => boolean;
+    installExtension: (name: string) => Promise<void>;
+    installExtensions: (packageJsonPath: string, packagesJson: PackageJson) => Promise<void>;
+    extensionPackageRootDirectory: string;
+}
 export interface InstalledExtension {
     id: LensExtensionId;
     readonly manifest: LensExtensionManifest;
@@ -48,7 +61,8 @@ interface LoadFromFolderOptions {
  * - "add": When extension is added. The event is of type InstalledExtension
  * - "remove": When extension is removed. The event is of type LensExtensionId
  */
-export declare class ExtensionDiscovery extends Singleton {
+export declare class ExtensionDiscovery {
+    protected dependencies: Dependencies;
     protected bundledFolderPath: string;
     private loadStarted;
     private extensions;
@@ -58,7 +72,7 @@ export declare class ExtensionDiscovery extends Singleton {
     };
     protected static readonly extensionDiscoveryChannel = "extension-discovery:main";
     events: EventEmitter;
-    constructor();
+    constructor(dependencies: Dependencies);
     get localFolderPath(): string;
     get packageJsonPath(): string;
     get inTreeTargetPath(): string;
@@ -118,7 +132,6 @@ export declare class ExtensionDiscovery extends Singleton {
      * Write package.json to file system and install dependencies.
      */
     installBundledPackages(packageJsonPath: string, extensions: InstalledExtension[]): Promise<void>;
-    installPackage(name: string): Promise<void>;
     loadBundledExtensions(): Promise<InstalledExtension[]>;
     loadFromFolder(folderPath: string, bundledExtensions: string[]): Promise<InstalledExtension[]>;
     /**

package/dist/src/extensions/extension-discovery/extension-discovery.injectable.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="@ogre-tools/injectable" />
+import { ExtensionDiscovery } from "./extension-discovery";
+declare const extensionDiscoveryInjectable: import("@ogre-tools/injectable").Injectable<import("@ogre-tools/injectable").InjectionToken<ExtensionDiscovery, unknown>, ExtensionDiscovery, unknown>;
+export default extensionDiscoveryInjectable;

package/dist/src/extensions/extension-discovery/is-compatible-bundled-extension/is-compatible-bundled-extension.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.
+ */
+import type { LensExtensionManifest } from "../../lens-extension";
+import type { SemVer } from "semver";
+interface Dependencies {
+    appSemVer: SemVer;
+}
+export declare const isCompatibleBundledExtension: ({ appSemVer }: Dependencies) => (manifest: LensExtensionManifest) => boolean;
+export {};

package/dist/src/extensions/extension-discovery/is-compatible-bundled-extension/is-compatible-bundled-extension.injectable.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="@ogre-tools/injectable" />
+declare const isCompatibleBundledExtensionInjectable: import("@ogre-tools/injectable").Injectable<import("@ogre-tools/injectable").InjectionToken<(manifest: import("../../lens-extension").LensExtensionManifest) => boolean, unknown>, (manifest: import("../../lens-extension").LensExtensionManifest) => boolean, unknown>;
+export default isCompatibleBundledExtensionInjectable;

package/dist/src/extensions/extension-discovery/is-compatible-extension/is-compatible-extension.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.
+ */
+import { SemVer } from "semver";
+import type { LensExtensionManifest } from "../../lens-extension";
+interface Dependencies {
+    appSemVer: SemVer;
+}
+export declare const isCompatibleExtension: ({ appSemVer, }: Dependencies) => (manifest: LensExtensionManifest) => boolean;
+export {};

package/dist/src/extensions/extension-discovery/is-compatible-extension/is-compatible-extension.injectable.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="@ogre-tools/injectable" />
+declare const isCompatibleExtensionInjectable: import("@ogre-tools/injectable").Injectable<import("@ogre-tools/injectable").InjectionToken<(manifest: import("../../lens-extension").LensExtensionManifest) => boolean, unknown>, (manifest: import("../../lens-extension").LensExtensionManifest) => boolean, unknown>;
+export default isCompatibleExtensionInjectable;

package/dist/src/{renderer/components/+extensions/extension-install.store.d.ts → extensions/extension-installation-state-store/extension-installation-state-store.d.ts}

@@ -18,107 +18,106 @@
  * 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 { ExtendableDisposer } from "../../utils";
+import type { ExtendableDisposer } from "../../renderer/utils";
 export declare enum ExtensionInstallationState {
     INSTALLING = "installing",
     UNINSTALLING = "uninstalling",
     IDLE = "idle"
 }
 export declare class ExtensionInstallationStateStore {
-    private static InstallingFromMainChannel;
-    private static ClearInstallingFromMainChannel;
-    private static PreInstallIds;
-    private static UninstallingExtensions;
-    private static InstallingExtensions;
-    static bindIpcListeners(): void;
-    static reset(): void;
+    private InstallingFromMainChannel;
+    private ClearInstallingFromMainChannel;
+    private PreInstallIds;
+    private UninstallingExtensions;
+    private InstallingExtensions;
+    bindIpcListeners: () => void;
     /**
      * Strictly transitions an extension from not installing to installing
      * @param extId the ID of the extension
      * @throws if state is not IDLE
      */
-    static setInstalling(extId: string): void;
+    setInstalling: (extId: string) => void;
     /**
      * Broadcasts that an extension is being installed by the main process
      * @param extId the ID of the extension
      */
-    static setInstallingFromMain(extId: string): void;
+    setInstallingFromMain: (extId: string) => void;
     /**
      * Broadcasts that an extension is no longer being installed by the main process
      * @param extId the ID of the extension
      */
-    static clearInstallingFromMain(extId: string): void;
+    clearInstallingFromMain: (extId: string) => void;
     /**
      * Marks the start of a pre-install phase of an extension installation. The
      * part of the installation before the tarball has been unpacked and the ID
      * determined.
      * @returns a disposer which should be called to mark the end of the install phase
      */
-    static startPreInstall(): ExtendableDisposer;
+    startPreInstall: () => ExtendableDisposer;
     /**
      * Strictly transitions an extension from not uninstalling to uninstalling
      * @param extId the ID of the extension
      * @throws if state is not IDLE
      */
-    static setUninstalling(extId: string): void;
+    setUninstalling: (extId: string) => void;
     /**
      * Strictly clears the INSTALLING state of an extension
      * @param extId The ID of the extension
      * @throws if state is not INSTALLING
      */
-    static clearInstalling(extId: string): void;
+    clearInstalling: (extId: string) => void;
     /**
      * Strictly clears the UNINSTALLING state of an extension
      * @param extId The ID of the extension
      * @throws if state is not UNINSTALLING
      */
-    static clearUninstalling(extId: string): void;
+    clearUninstalling: (extId: string) => void;
     /**
      * Returns the current state of the extension. IDLE is default value.
      * @param extId The ID of the extension
      */
-    static getInstallationState(extId: string): ExtensionInstallationState;
+    getInstallationState: (extId: string) => ExtensionInstallationState;
     /**
      * Returns true if the extension is currently INSTALLING
      * @param extId The ID of the extension
      */
-    static isExtensionInstalling(extId: string): boolean;
+    isExtensionInstalling: (extId: string) => boolean;
     /**
      * Returns true if the extension is currently UNINSTALLING
      * @param extId The ID of the extension
      */
-    static isExtensionUninstalling(extId: string): boolean;
+    isExtensionUninstalling: (extId: string) => boolean;
     /**
      * Returns true if the extension is currently IDLE
      * @param extId The ID of the extension
      */
-    static isExtensionIdle(extId: string): boolean;
+    isExtensionIdle: (extId: string) => boolean;
     /**
      * The current number of extensions installing
      */
-    static get installing(): number;
+    get installing(): number;
     /**
      * The current number of extensions uninstalling
      */
-    static get uninstalling(): number;
+    get uninstalling(): number;
     /**
      * If there is at least one extension currently installing
      */
-    static get anyInstalling(): boolean;
+    get anyInstalling(): boolean;
     /**
      * If there is at least one extension currently uninstalling
      */
-    static get anyUninstalling(): boolean;
+    get anyUninstalling(): boolean;
     /**
      * The current number of extensions preinstalling
      */
-    static get preinstalling(): number;
+    get preinstalling(): number;
     /**
      * If there is at least one extension currently downloading
      */
-    static get anyPreinstalling(): boolean;
+    get anyPreinstalling(): boolean;
     /**
-      * If there is at least one installing or preinstalling step taking place
-      */
-    static get anyPreInstallingOrInstalling(): boolean;
+     * If there is at least one installing or preinstalling step taking place
+     */
+    get anyPreInstallingOrInstalling(): boolean;
 }

package/dist/src/extensions/extension-installation-state-store/extension-installation-state-store.injectable.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="@ogre-tools/injectable" />
+import { ExtensionInstallationStateStore } from "./extension-installation-state-store";
+declare const extensionInstallationStateStoreInjectable: import("@ogre-tools/injectable").Injectable<import("@ogre-tools/injectable").InjectionToken<ExtensionInstallationStateStore, unknown>, ExtensionInstallationStateStore, unknown>;
+export default extensionInstallationStateStoreInjectable;

package/dist/src/extensions/{extension-installer.d.ts → extension-installer/extension-installer.d.ts}

@@ -19,21 +19,25 @@
  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 import type { PackageJson } from "type-fest";
+interface Dependencies {
+    extensionPackageRootDirectory: string;
+}
 /**
  * Installs dependencies for extensions
  */
 export declare class ExtensionInstaller {
+    private dependencies;
     private installLock;
-    get extensionPackagesRoot(): string;
+    constructor(dependencies: Dependencies);
     get npmPath(): any;
     /**
      * Write package.json to the file system and execute npm install for it.
      */
-    installPackages(packageJsonPath: string, packagesJson: PackageJson): Promise<void>;
+    installPackages: (packageJsonPath: string, packagesJson: PackageJson) => Promise<void>;
     /**
      * Install single package using npm
      */
-    installPackage(name: string): Promise<void>;
+    installPackage: (name: string) => Promise<void>;
     private npm;
 }
-export declare const extensionInstaller: ExtensionInstaller;
+export {};

package/dist/src/extensions/extension-installer/extension-installer.injectable.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="@ogre-tools/injectable" />
+import { ExtensionInstaller } from "./extension-installer";
+declare const extensionInstallerInjectable: import("@ogre-tools/injectable").Injectable<import("@ogre-tools/injectable").InjectionToken<ExtensionInstaller, unknown>, ExtensionInstaller, unknown>;
+export default extensionInstallerInjectable;

package/dist/src/extensions/extension-installer/extension-package-root-directory/extension-package-root-directory.injectable.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="@ogre-tools/injectable" />
+declare const extensionPackageRootDirectoryInjectable: import("@ogre-tools/injectable").Injectable<import("@ogre-tools/injectable").InjectionToken<string, unknown>, string, unknown>;
+export default extensionPackageRootDirectoryInjectable;

package/dist/src/extensions/extension-installer/install-extension/install-extension.injectable.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="@ogre-tools/injectable" />
+declare const installExtensionInjectable: import("@ogre-tools/injectable").Injectable<import("@ogre-tools/injectable").InjectionToken<(name: string) => Promise<void>, unknown>, (name: string) => Promise<void>, unknown>;
+export default installExtensionInjectable;

package/dist/src/extensions/extension-installer/install-extensions/install-extensions.injectable.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="@ogre-tools/injectable" />
+declare const installExtensionsInjectable: import("@ogre-tools/injectable").Injectable<import("@ogre-tools/injectable").InjectionToken<(packageJsonPath: string, packagesJson: import("type-fest").PackageJson) => Promise<void>, unknown>, (packageJsonPath: string, packagesJson: import("type-fest").PackageJson) => Promise<void>, unknown>;
+export default installExtensionsInjectable;

package/dist/src/extensions/extension-loader/create-extension-instance/create-extension-instance.d.ts

@@ -0,0 +1,24 @@
+/**
+ * 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 type { LensExtensionConstructor } from "../../lens-extension";
+import type { InstalledExtension } from "../../extension-discovery/extension-discovery";
+import { LensExtensionDependencies } from "../../lens-extension-set-dependencies";
+export declare const createExtensionInstance: (dependencies: LensExtensionDependencies) => (ExtensionClass: LensExtensionConstructor, extension: InstalledExtension) => import("../../lens-extension").LensExtension;

package/dist/src/extensions/extension-loader/create-extension-instance/create-extension-instance.injectable.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="@ogre-tools/injectable" />
+declare const createExtensionInstanceInjectable: import("@ogre-tools/injectable").Injectable<import("@ogre-tools/injectable").InjectionToken<(ExtensionClass: import("../../lens-extension").LensExtensionConstructor, extension: import("../../extension-discovery/extension-discovery").InstalledExtension) => import("../../lens-extension").LensExtension, unknown>, (ExtensionClass: import("../../lens-extension").LensExtensionConstructor, extension: import("../../extension-discovery/extension-discovery").InstalledExtension) => import("../../lens-extension").LensExtension, unknown>;
+export default createExtensionInstanceInjectable;

package/dist/src/extensions/extension-loader/create-extension-instance/file-system-provisioner-store/directory-for-extension-data/directory-for-extension-data.injectable.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="@ogre-tools/injectable" />
+declare const directoryForExtensionDataInjectable: import("@ogre-tools/injectable").Injectable<import("@ogre-tools/injectable").InjectionToken<string, unknown>, string, unknown>;
+export default directoryForExtensionDataInjectable;

package/dist/src/{main/extension-filesystem.d.ts → extensions/extension-loader/create-extension-instance/file-system-provisioner-store/file-system-provisioner-store.d.ts}

@@ -18,14 +18,18 @@
  * 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 { BaseStore } from "../common/base-store";
+import { BaseStore } from "../../../../common/base-store";
 interface FSProvisionModel {
     extensions: Record<string, string>;
 }
-export declare class FilesystemProvisionerStore extends BaseStore<FSProvisionModel> {
+interface Dependencies {
+    directoryForExtensionData: string;
+}
+export declare class FileSystemProvisionerStore extends BaseStore<FSProvisionModel> {
+    private dependencies;
     readonly displayName = "FilesystemProvisionerStore";
     registeredExtensions: import("mobx").ObservableMap<string, string>;
-    constructor();
+    constructor(dependencies: Dependencies);
     /**
      * This function retrieves the saved path to the folder which the extension
      * can saves files to. If the folder is not present then it is created.

package/dist/src/extensions/extension-loader/create-extension-instance/file-system-provisioner-store/file-system-provisioner-store.injectable.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="@ogre-tools/injectable" />
+import { FileSystemProvisionerStore } from "./file-system-provisioner-store";
+declare const fileSystemProvisionerStoreInjectable: import("@ogre-tools/injectable").Injectable<import("@ogre-tools/injectable").InjectionToken<FileSystemProvisionerStore, unknown>, FileSystemProvisionerStore, unknown>;
+export default fileSystemProvisionerStoreInjectable;

package/dist/src/extensions/{extension-loader.d.ts → extension-loader/extension-loader.d.ts}

@@ -18,14 +18,24 @@
  * 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 { Disposer, Singleton } from "../common/utils";
-import type { InstalledExtension } from "./extension-discovery";
-import type { LensExtension, LensExtensionConstructor, LensExtensionId } from "./lens-extension";
-export declare function extensionPackagesRoot(): string;
+import { Disposer } from "../../common/utils";
+import type { KubernetesCluster } from "../common-api/catalog";
+import type { InstalledExtension } from "../extension-discovery/extension-discovery";
+import type { LensExtension, LensExtensionConstructor, LensExtensionId } from "../lens-extension";
+import type { LensExtensionState } from "../extensions-store/extensions-store";
+interface Dependencies {
+    updateExtensionsState: (extensionsState: Record<LensExtensionId, LensExtensionState>) => void;
+    createExtensionInstance: (ExtensionClass: LensExtensionConstructor, extension: InstalledExtension) => LensExtension;
+}
+export interface ExtensionLoading {
+    isBundled: boolean;
+    loaded: Promise<void>;
+}
 /**
  * Loads installed extensions to the Lens application
  */
-export declare class ExtensionLoader extends Singleton {
+export declare class ExtensionLoader {
+    protected dependencies: Dependencies;
     protected extensions: import("mobx").ObservableMap<string, InstalledExtension>;
     protected instances: import("mobx").ObservableMap<string, LensExtension>;
     /**
@@ -45,7 +55,8 @@ export declare class ExtensionLoader extends Singleton {
     get whenLoaded(): Promise<void> & {
         cancel(): void;
     };
-    constructor();
+    constructor(dependencies: Dependencies);
+    get enabledExtensionInstances(): LensExtension[];
     get userExtensions(): Map<LensExtensionId, InstalledExtension>;
     /**
      * Get the extension instance by its manifest name
@@ -74,11 +85,12 @@ export declare class ExtensionLoader extends Singleton {
     broadcastExtensions(): void;
     syncExtensions(extensions: [LensExtensionId, InstalledExtension][]): void;
     loadOnMain(): void;
-    loadOnClusterManagerRenderer(): void;
-    loadOnClusterRenderer(): void;
-    protected autoInitExtensions(register: (ext: LensExtension) => Promise<Disposer[]>): import("mobx").IReactionDisposer;
+    loadOnClusterManagerRenderer: () => ExtensionLoading[];
+    loadOnClusterRenderer: (entity: KubernetesCluster) => void;
+    protected autoInitExtensions(register: (ext: LensExtension) => Promise<Disposer[]>): ExtensionLoading[];
     protected requireExtension(extension: InstalledExtension): LensExtensionConstructor | null;
     getExtension(extId: LensExtensionId): InstalledExtension;
     getInstanceById<E extends LensExtension>(extId: LensExtensionId): E;
     toJSON(): Map<LensExtensionId, InstalledExtension>;
 }
+export {};

package/dist/src/extensions/extension-loader/extension-loader.injectable.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="@ogre-tools/injectable" />
+import { ExtensionLoader } from "./extension-loader";
+declare const extensionLoaderInjectable: import("@ogre-tools/injectable").Injectable<import("@ogre-tools/injectable").InjectionToken<ExtensionLoader, unknown>, ExtensionLoader, unknown>;
+export default extensionLoaderInjectable;

package/dist/src/{renderer/components/+404 → extensions/extension-loader}/index.d.ts

@@ -18,4 +18,4 @@
  * 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 * from "./not-found";
+export * from "./extension-loader";

package/dist/src/extensions/extension-loader/update-extensions-state/update-extensions-state.injectable.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="@ogre-tools/injectable" />
+declare const updateExtensionsStateInjectable: import("@ogre-tools/injectable").Injectable<import("@ogre-tools/injectable").InjectionToken<(extensionsState: Record<string, import("../../extensions-store/extensions-store").LensExtensionState>) => void, unknown>, (extensionsState: Record<string, import("../../extensions-store/extensions-store").LensExtensionState>) => void, unknown>;
+export default updateExtensionsStateInjectable;

package/dist/src/extensions/extension-packages-root/extension-packages-root.injectable.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="@ogre-tools/injectable" />
+declare const extensionPackagesRootInjectable: import("@ogre-tools/injectable").Injectable<import("@ogre-tools/injectable").InjectionToken<string, unknown>, string, unknown>;
+export default extensionPackagesRootInjectable;

package/dist/src/extensions/{extensions-store.d.ts → extensions-store/extensions-store.d.ts}

@@ -18,8 +18,8 @@
  * 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 { LensExtensionId } from "./lens-extension";
-import { BaseStore } from "../common/base-store";
+import type { LensExtensionId } from "../lens-extension";
+import { BaseStore } from "../../common/base-store";
 export interface LensExtensionsStoreModel {
     extensions: Record<LensExtensionId, LensExtensionState>;
 }
@@ -36,7 +36,7 @@ export declare class ExtensionsStore extends BaseStore<LensExtensionsStoreModel>
         id: string;
         isBundled: boolean;
     }): boolean;
-    mergeState(extensionsState: Record<LensExtensionId, LensExtensionState>): void;
+    mergeState: (extensionsState: Record<LensExtensionId, LensExtensionState>) => void;
     protected fromStore({ extensions }: LensExtensionsStoreModel): void;
     toJSON(): LensExtensionsStoreModel;
 }

package/dist/src/extensions/extensions-store/extensions-store.injectable.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="@ogre-tools/injectable" />
+import { ExtensionsStore } from "./extensions-store";
+declare const extensionsStoreInjectable: import("@ogre-tools/injectable").Injectable<import("@ogre-tools/injectable").InjectionToken<ExtensionsStore, unknown>, ExtensionsStore, unknown>;
+export default extensionsStoreInjectable;

package/dist/src/extensions/extensions.injectable.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="@ogre-tools/injectable" />
+declare const extensionsInjectable: import("@ogre-tools/injectable").Injectable<import("@ogre-tools/injectable").InjectionToken<import("mobx").IComputedValue<import("./lens-extension").LensExtension[]>, unknown>, import("mobx").IComputedValue<import("./lens-extension").LensExtension[]>, unknown>;
+export default extensionsInjectable;

package/dist/src/extensions/{registries/menu-registry.d.ts → lens-extension-set-dependencies.d.ts}

@@ -18,10 +18,8 @@
  * 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 { MenuItemConstructorOptions } from "electron";
-import { BaseRegistry } from "./base-registry";
-export interface MenuRegistration extends MenuItemConstructorOptions {
-    parentId: string;
-}
-export declare class MenuRegistry extends BaseRegistry<MenuRegistration> {
+import type { FileSystemProvisionerStore } from "./extension-loader/create-extension-instance/file-system-provisioner-store/file-system-provisioner-store";
+export declare const setLensExtensionDependencies: unique symbol;
+export interface LensExtensionDependencies {
+    fileSystemProvisionerStore: FileSystemProvisionerStore;
 }

package/dist/src/extensions/lens-extension.d.ts

@@ -18,10 +18,11 @@
  * 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 { InstalledExtension } from "./extension-discovery";
+import type { InstalledExtension } from "./extension-discovery/extension-discovery";
 import type { ProtocolHandlerRegistration } from "./registries";
 import type { PackageJson } from "type-fest";
 import { Disposer } from "../common/utils";
+import { LensExtensionDependencies, setLensExtensionDependencies } from "./lens-extension-set-dependencies";
 export declare type LensExtensionId = string;
 export declare type LensExtensionConstructor = new (...args: ConstructorParameters<typeof LensExtension>) => LensExtension;
 export interface LensExtensionManifest extends PackageJson {
@@ -37,12 +38,15 @@ export declare class LensExtension {
     readonly manifestPath: string;
     readonly isBundled: boolean;
     protocolHandlers: ProtocolHandlerRegistration[];
-    private isEnabled;
+    private _isEnabled;
+    get isEnabled(): boolean;
     [Disposers]: import("../common/utils").ExtendableDisposer;
     constructor({ id, manifest, manifestPath, isBundled }: InstalledExtension);
     get name(): string;
     get version(): string;
     get description(): string;
+    private dependencies;
+    [setLensExtensionDependencies]: (dependencies: LensExtensionDependencies) => void;
     /**
      * getExtensionFileFolder returns the path to an already created folder. This
      * folder is for the sole use of this extension.

package/dist/src/extensions/lens-main-extension.d.ts

@@ -21,9 +21,11 @@
 import { LensExtension } from "./lens-extension";
 import type { CatalogEntity } from "../common/catalog";
 import type { IObservableArray } from "mobx";
-import type { MenuRegistration } from "./registries";
+import type { MenuRegistration } from "../main/menu/menu-registration";
+import type { TrayMenuRegistration } from "../main/tray/tray-menu-registration";
 export declare class LensMainExtension extends LensExtension {
     appMenus: MenuRegistration[];
+    trayMenus: TrayMenuRegistration[];
     navigate(pageId?: string, params?: Record<string, any>, frameId?: number): Promise<void>;
     addCatalogSource(id: string, source: IObservableArray<CatalogEntity>): void;
     removeCatalogSource(id: string): void;

package/dist/src/extensions/lens-renderer-extension.d.ts

@@ -19,12 +19,16 @@
  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 import type * as registries from "./registries";
-import type { Cluster } from "../main/cluster";
 import { LensExtension } from "./lens-extension";
 import type { CatalogEntity } from "../common/catalog";
 import type { Disposer } from "../common/utils";
 import { EntityFilter } from "../renderer/api/catalog-entity-registry";
 import { CategoryFilter } from "../renderer/api/catalog-category-registry";
+import type { TopBarRegistration } from "../renderer/components/layout/top-bar/top-bar-registration";
+import type { KubernetesCluster } from "../common/catalog-entities";
+import type { WelcomeMenuRegistration } from "../renderer/components/+welcome/welcome-menu-items/welcome-menu-registration";
+import type { WelcomeBannerRegistration } from "../renderer/components/+welcome/welcome-banner-items/welcome-banner-registration";
+import type { CommandRegistration } from "../renderer/components/command-palette/registered-commands/commands";
 export declare class LensRendererExtension extends LensExtension {
     globalPages: registries.PageRegistration[];
     clusterPages: registries.PageRegistration[];
@@ -36,16 +40,19 @@ export declare class LensRendererExtension extends LensExtension {
     kubeObjectDetailItems: registries.KubeObjectDetailRegistration[];
     kubeObjectMenuItems: registries.KubeObjectMenuRegistration[];
     kubeWorkloadsOverviewItems: registries.WorkloadsOverviewDetailRegistration[];
-    commands: registries.CommandRegistration[];
-    welcomeMenus: registries.WelcomeMenuRegistration[];
-    welcomeBanners: registries.WelcomeBannerRegistration[];
+    commands: CommandRegistration[];
+    welcomeMenus: WelcomeMenuRegistration[];
+    welcomeBanners: WelcomeBannerRegistration[];
     catalogEntityDetailItems: registries.CatalogEntityDetailRegistration<CatalogEntity>[];
-    topBarItems: registries.TopBarRegistration[];
+    topBarItems: TopBarRegistration[];
     navigate<P extends object>(pageId?: string, params?: P): Promise<void>;
     /**
-     * Defines if extension is enabled for a given cluster. Defaults to `true`.
+     * Defines if extension is enabled for a given cluster. This method is only
+     * called when the extension is created within a cluster frame.
+     *
+     * The default implementation is to return `true`
      */
-    isEnabledForCluster(cluster: Cluster): Promise<Boolean>;
+    isEnabledForCluster(cluster: KubernetesCluster): Promise<Boolean>;
     /**
      * Add a filtering function for the catalog entities. This will be removed if the extension is disabled.
      * @param fn The function which should return a truthy value for those entities which should be kept.

package/dist/src/extensions/main-extensions.injectable.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="@ogre-tools/injectable" />
+import type { IComputedValue } from "mobx";
+import type { LensMainExtension } from "./lens-main-extension";
+declare const mainExtensionsInjectable: import("@ogre-tools/injectable").Injectable<import("@ogre-tools/injectable").InjectionToken<IComputedValue<LensMainExtension[]>, unknown>, IComputedValue<LensMainExtension[]>, unknown>;
+export default mainExtensionsInjectable;

package/dist/src/extensions/registries/base-registry.d.ts

@@ -19,7 +19,7 @@
  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 import { Singleton } from "../../common/utils";
-import { LensExtension } from "../lens-extension";
+import type { LensExtension } from "../lens-extension";
 export declare class BaseRegistry<T, I = T> extends Singleton {
     private items;
     constructor();