Restructure to monorepo (#6907)

* wip: restructure to monorepo

Signed-off-by: Jari Kolehmainen <jari.kolehmainen@gmail.com>

* refactor create-release-pr to a package

Signed-off-by: Jari Kolehmainen <jari.kolehmainen@gmail.com>

* build fixes

Signed-off-by: Jari Kolehmainen <jari.kolehmainen@gmail.com>

* github workflow fixes

Signed-off-by: Jari Kolehmainen <jari.kolehmainen@gmail.com>

* fix typo

Signed-off-by: Jari Kolehmainen <jari.kolehmainen@gmail.com>

* add webpack-env types to core

Signed-off-by: Jari Kolehmainen <jari.kolehmainen@gmail.com>

* fix github workflows

Signed-off-by: Jari Kolehmainen <jari.kolehmainen@gmail.com>

* refactor/fix integration tests

Signed-off-by: Jari Kolehmainen <jari.kolehmainen@gmail.com>

* lint fix

Signed-off-by: Jari Kolehmainen <jari.kolehmainen@gmail.com>

* yarn run dev

Signed-off-by: Jari Kolehmainen <jari.kolehmainen@gmail.com>

* eslint settings for vscode

Signed-off-by: Jari Kolehmainen <jari.kolehmainen@gmail.com>

* move templates to right package

Signed-off-by: Jari Kolehmainen <jari.kolehmainen@gmail.com>

* open-lens build fixes

Signed-off-by: Jari Kolehmainen <jari.kolehmainen@gmail.com>

* integration test fix

Signed-off-by: Jari Kolehmainen <jari.kolehmainen@gmail.com>

* fix nx task dependencies

Signed-off-by: Jari Kolehmainen <jari.kolehmainen@gmail.com>

* use bash shell for unit tests in test workflow

Signed-off-by: Jari Kolehmainen <jari.kolehmainen@gmail.com>

* fix test:unit for windows

Signed-off-by: Jari Kolehmainen <jari.kolehmainen@gmail.com>

* fix win-ca webpack error in open-lens

Signed-off-by: Jari Kolehmainen <jari.kolehmainen@gmail.com>

* fix win-ca webpack error in open-lens

Signed-off-by: Jari Kolehmainen <jari.kolehmainen@gmail.com>

* fix build:app on windows

Signed-off-by: Jari Kolehmainen <jari.kolehmainen@gmail.com>

* remove ELECTRON_BUILDER_EXTRA_ARGS

Signed-off-by: Jari Kolehmainen <jari.kolehmainen@gmail.com>

* sync src/ from master

Signed-off-by: Jari Kolehmainen <jari.kolehmainen@gmail.com>

* remove Makefile from core

Signed-off-by: Jari Kolehmainen <jari.kolehmainen@gmail.com>

Signed-off-by: Jari Kolehmainen <jari.kolehmainen@gmail.com>

packages/core/src/common/front-end-routing/app-navigation-channel.ts

@@ -0,0 +1,12 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { IpcRendererNavigationEvents } from "../ipc/navigation-events";
+import type { MessageChannel } from "../utils/channel/message-channel-listener-injection-token";
+
+export type AppNavigationChannel = MessageChannel<string>;
+
+export const appNavigationChannel: AppNavigationChannel = {
+  id: IpcRendererNavigationEvents.NAVIGATE_IN_APP,
+};

packages/core/src/common/front-end-routing/cluster-frame-navigation-channel.ts

@@ -0,0 +1,12 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { IpcRendererNavigationEvents } from "../ipc/navigation-events";
+import type { MessageChannel } from "../utils/channel/message-channel-listener-injection-token";
+
+export type ClusterFrameNavigationChannel = MessageChannel<string>;
+
+export const clusterFrameNavigationChannel: ClusterFrameNavigationChannel = {
+  id: IpcRendererNavigationEvents.NAVIGATE_IN_CLUSTER,
+};

packages/core/src/common/front-end-routing/front-end-route-injection-token.ts

@@ -0,0 +1,20 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectionToken } from "@ogre-tools/injectable";
+import type { IComputedValue } from "mobx";
+import type { LensRendererExtension } from "../../extensions/lens-renderer-extension";
+
+export const frontEndRouteInjectionToken = getInjectionToken<Route<unknown>>({
+  id: "front-end-route-injection-token",
+});
+
+export interface Route<TParameter = void> {
+  path: string;
+  clusterFrame: boolean;
+  isEnabled: IComputedValue<boolean>;
+  extension?: LensRendererExtension;
+
+  readonly parameterSignature?: TParameter;
+}

packages/core/src/common/front-end-routing/navigate-to-front-page.injectable.ts

@@ -0,0 +1,13 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import navigateToCatalogInjectable from "./routes/catalog/navigate-to-catalog.injectable";
+
+const navigateToFrontPageInjectable = getInjectable({
+  id: "navigate-to-front-page",
+  instantiate: (di) => di.inject(navigateToCatalogInjectable),
+});
+
+export default navigateToFrontPageInjectable;

packages/core/src/common/front-end-routing/navigate-to-route-injection-token.ts

@@ -0,0 +1,52 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectionToken } from "@ogre-tools/injectable";
+import type { Route } from "./front-end-route-injection-token";
+
+type InferParametersFrom<TRoute> = TRoute extends Route<infer TParameters>
+  ? TParameters
+  : never;
+
+type RequiredKeys<T> = Exclude<
+  {
+    [K in keyof T]: T extends Record<K, T[K]> ? K : never;
+  }[keyof T],
+  undefined
+>;
+
+type ObjectContainingNoRequired<T> = T extends void
+  ? never
+  : RequiredKeys<T> extends []
+  ? any
+  : never;
+
+type ObjectContainsNoRequired<T> = T extends ObjectContainingNoRequired<T>
+  ? true
+  : false;
+
+// TODO: Missing types for:
+// - Navigating to route without parameters, with parameters
+// - Navigating to route with required parameters, without parameters
+type Parameters<TParameters> = TParameters extends void
+  ? {}
+  : ObjectContainsNoRequired<TParameters> extends true
+  ? { parameters?: TParameters }
+  : { parameters: TParameters };
+
+export type NavigateToRouteOptions<TRoute> = Parameters<
+  InferParametersFrom<TRoute>
+> & {
+  query?: Record<string, string>;
+  fragment?: string;
+  withoutAffectingBackButton?: boolean;
+};
+
+export type NavigateToRoute = <TRoute extends Route<unknown>>(
+  route: TRoute,
+  options?: NavigateToRouteOptions<TRoute>) => void;
+
+export const navigateToRouteInjectionToken = getInjectionToken<NavigateToRoute>(
+  { id: "navigate-to-route-injection-token" },
+);

packages/core/src/common/front-end-routing/navigate-to-url-injection-token.ts

@@ -0,0 +1,16 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectionToken } from "@ogre-tools/injectable";
+
+export interface NavigateToUrlOptions {
+  withoutAffectingBackButton?: boolean;
+  forceRootFrame?: boolean;
+}
+
+export type NavigateToUrl = (url: string, options?: NavigateToUrlOptions) => void;
+
+export const navigateToUrlInjectionToken = getInjectionToken<NavigateToUrl>(
+  { id: "navigate-to-url-injection-token" },
+);

packages/core/src/common/front-end-routing/routes/add-cluster/add-cluster-route.injectable.ts

@@ -0,0 +1,21 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import { computed } from "mobx";
+import { frontEndRouteInjectionToken } from "../../front-end-route-injection-token";
+
+const addClusterRouteInjectable = getInjectable({
+  id: "add-cluster-route",
+
+  instantiate: () => ({
+    path: "/add-cluster",
+    clusterFrame: false,
+    isEnabled: computed(() => true),
+  }),
+
+  injectionToken: frontEndRouteInjectionToken,
+});
+
+export default addClusterRouteInjectable;

packages/core/src/common/front-end-routing/routes/add-cluster/navigate-to-add-cluster.injectable.ts

@@ -0,0 +1,20 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import addClusterRouteInjectable from "./add-cluster-route.injectable";
+import { navigateToRouteInjectionToken } from "../../navigate-to-route-injection-token";
+
+const navigateToAddClusterInjectable = getInjectable({
+  id: "navigate-to-add-cluster",
+
+  instantiate: (di) => {
+    const navigateToRoute = di.inject(navigateToRouteInjectionToken);
+    const route = di.inject(addClusterRouteInjectable);
+
+    return () => navigateToRoute(route);
+  },
+});
+
+export default navigateToAddClusterInjectable;

packages/core/src/common/front-end-routing/routes/catalog/catalog-route.injectable.ts

@@ -0,0 +1,27 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import { computed } from "mobx";
+import type { Route } from "../../front-end-route-injection-token";
+import { frontEndRouteInjectionToken } from "../../front-end-route-injection-token";
+
+export interface CatalogPathParameters {
+  group?: string;
+  kind?: string;
+}
+
+const catalogRouteInjectable = getInjectable({
+  id: "catalog-route",
+
+  instantiate: (): Route<CatalogPathParameters> => ({
+    path: "/catalog/:group?/:kind?",
+    clusterFrame: false,
+    isEnabled: computed(() => true),
+  }),
+
+  injectionToken: frontEndRouteInjectionToken,
+});
+
+export default catalogRouteInjectable;

packages/core/src/common/front-end-routing/routes/catalog/navigate-to-catalog.injectable.ts

@@ -0,0 +1,26 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import type { CatalogPathParameters } from "./catalog-route.injectable";
+import catalogRouteInjectable from "./catalog-route.injectable";
+import { navigateToRouteInjectionToken } from "../../navigate-to-route-injection-token";
+
+export type NavigateToCatalog = (parameters?: CatalogPathParameters) => void;
+
+const navigateToCatalogInjectable = getInjectable({
+  id: "navigate-to-catalog",
+
+  instantiate: (di): NavigateToCatalog => {
+    const navigateToRoute = di.inject(navigateToRouteInjectionToken);
+    const catalogRoute = di.inject(catalogRouteInjectable);
+
+    return (parameters) =>
+      navigateToRoute(catalogRoute, {
+        parameters,
+      });
+  },
+});
+
+export default navigateToCatalogInjectable;

packages/core/src/common/front-end-routing/routes/cluster-view/cluster-view-route.injectable.ts

@@ -0,0 +1,21 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import { computed } from "mobx";
+import { frontEndRouteInjectionToken } from "../../front-end-route-injection-token";
+
+const clusterViewRouteInjectable = getInjectable({
+  id: "cluster-view-route",
+
+  instantiate: () => ({
+    path: "/cluster/:clusterId",
+    clusterFrame: false,
+    isEnabled: computed(() => true),
+  }),
+
+  injectionToken: frontEndRouteInjectionToken,
+});
+
+export default clusterViewRouteInjectable;

packages/core/src/common/front-end-routing/routes/cluster-view/navigate-to-cluster-view.injectable.ts

@@ -0,0 +1,23 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import { navigateToRouteInjectionToken } from "../../navigate-to-route-injection-token";
+import clusterViewRouteInjectable from "./cluster-view-route.injectable";
+
+export type NavigateToClusterView = (clusterId: string) => void;
+
+const navigateToClusterViewInjectable = getInjectable({
+  id: "navigate-to-cluster-view",
+
+  instantiate: (di): NavigateToClusterView => {
+    const navigateToRoute = di.inject(navigateToRouteInjectionToken);
+    const route = di.inject(clusterViewRouteInjectable);
+
+    return (clusterId) =>
+      navigateToRoute(route, { parameters: { clusterId }});
+  },
+});
+
+export default navigateToClusterViewInjectable;

packages/core/src/common/front-end-routing/routes/cluster/config/config-maps/config-maps-route.injectable.ts

@@ -0,0 +1,22 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import { shouldShowResourceInjectionToken } from "../../../../../cluster-store/allowed-resources-injection-token";
+import { frontEndRouteInjectionToken } from "../../../../front-end-route-injection-token";
+
+const configMapsRouteInjectable = getInjectable({
+  id: "config-maps-route",
+  instantiate: (di) => ({
+    path: "/configmaps",
+    clusterFrame: true,
+    isEnabled: di.inject(shouldShowResourceInjectionToken, {
+      apiName: "configmaps",
+      group: "",
+    }),
+  }),
+  injectionToken: frontEndRouteInjectionToken,
+});
+
+export default configMapsRouteInjectable;

packages/core/src/common/front-end-routing/routes/cluster/config/config-maps/navigate-to-config-maps.injectable.ts

@@ -0,0 +1,20 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import configMapsRouteInjectable from "./config-maps-route.injectable";
+import { navigateToRouteInjectionToken } from "../../../../navigate-to-route-injection-token";
+
+const navigateToConfigMapsInjectable = getInjectable({
+  id: "navigate-to-config-maps",
+
+  instantiate: (di) => {
+    const navigateToRoute = di.inject(navigateToRouteInjectionToken);
+    const route = di.inject(configMapsRouteInjectable);
+
+    return () => navigateToRoute(route);
+  },
+});
+
+export default navigateToConfigMapsInjectable;

packages/core/src/common/front-end-routing/routes/cluster/config/horizontal-pod-autoscalers/horizontal-pod-autoscalers-route.injectable.ts

@@ -0,0 +1,24 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import { shouldShowResourceInjectionToken } from "../../../../../cluster-store/allowed-resources-injection-token";
+import { frontEndRouteInjectionToken } from "../../../../front-end-route-injection-token";
+
+const horizontalPodAutoscalersRouteInjectable = getInjectable({
+  id: "horizontal-pod-autoscalers-route",
+
+  instantiate: (di) => ({
+    path: "/hpa",
+    clusterFrame: true,
+    isEnabled: di.inject(shouldShowResourceInjectionToken, {
+      apiName: "horizontalpodautoscalers",
+      group: "autoscaling",
+    }),
+  }),
+
+  injectionToken: frontEndRouteInjectionToken,
+});
+
+export default horizontalPodAutoscalersRouteInjectable;

packages/core/src/common/front-end-routing/routes/cluster/config/horizontal-pod-autoscalers/navigate-to-horizontal-pod-autoscalers.injectable.ts

@@ -0,0 +1,20 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import horizontalPodAutoscalersRouteInjectable from "./horizontal-pod-autoscalers-route.injectable";
+import { navigateToRouteInjectionToken } from "../../../../navigate-to-route-injection-token";
+
+const navigateToHorizontalPodAutoscalersInjectable = getInjectable({
+  id: "navigate-to-horizontal-pod-autoscalers",
+
+  instantiate: (di) => {
+    const navigateToRoute = di.inject(navigateToRouteInjectionToken);
+    const route = di.inject(horizontalPodAutoscalersRouteInjectable);
+
+    return () => navigateToRoute(route);
+  },
+});
+
+export default navigateToHorizontalPodAutoscalersInjectable;

packages/core/src/common/front-end-routing/routes/cluster/config/leases/leases-route.injectable.ts

@@ -0,0 +1,24 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import { shouldShowResourceInjectionToken } from "../../../../../cluster-store/allowed-resources-injection-token";
+import { frontEndRouteInjectionToken } from "../../../../front-end-route-injection-token";
+
+const leasesRouteInjectable = getInjectable({
+  id: "leases",
+
+  instantiate: (di) => ({
+    path: "/leases",
+    clusterFrame: true,
+    isEnabled: di.inject(shouldShowResourceInjectionToken, {
+      apiName: "leases",
+      group: "coordination.k8s.io",
+    }),
+  }),
+
+  injectionToken: frontEndRouteInjectionToken,
+});
+
+export default leasesRouteInjectable;

packages/core/src/common/front-end-routing/routes/cluster/config/leases/navigate-to-leases.injectable.ts

@@ -0,0 +1,20 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import leasesRouteInjectable from "./leases-route.injectable";
+import { navigateToRouteInjectionToken } from "../../../../navigate-to-route-injection-token";
+
+const navigateToLeasesInjectable = getInjectable({
+  id: "navigate-to-leases",
+
+  instantiate: (di) => {
+    const navigateToRoute = di.inject(navigateToRouteInjectionToken);
+    const route = di.inject(leasesRouteInjectable);
+
+    return () => navigateToRoute(route);
+  },
+});
+
+export default navigateToLeasesInjectable;

packages/core/src/common/front-end-routing/routes/cluster/config/limit-ranges/limit-ranges-route.injectable.ts

@@ -0,0 +1,24 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import { shouldShowResourceInjectionToken } from "../../../../../cluster-store/allowed-resources-injection-token";
+import { frontEndRouteInjectionToken } from "../../../../front-end-route-injection-token";
+
+const limitRangesRouteInjectable = getInjectable({
+  id: "limit-ranges-route",
+
+  instantiate: (di) => ({
+    path: "/limitranges",
+    clusterFrame: true,
+    isEnabled: di.inject(shouldShowResourceInjectionToken, {
+      apiName: "limitranges",
+      group: "",
+    }),
+  }),
+
+  injectionToken: frontEndRouteInjectionToken,
+});
+
+export default limitRangesRouteInjectable;

packages/core/src/common/front-end-routing/routes/cluster/config/limit-ranges/navigate-to-limit-ranges.injectable.ts

@@ -0,0 +1,20 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import limitRangesRouteInjectable from "./limit-ranges-route.injectable";
+import { navigateToRouteInjectionToken } from "../../../../navigate-to-route-injection-token";
+
+const navigateToLimitRangesInjectable = getInjectable({
+  id: "navigate-to-limit-ranges",
+
+  instantiate: (di) => {
+    const navigateToRoute = di.inject(navigateToRouteInjectionToken);
+    const route = di.inject(limitRangesRouteInjectable);
+
+    return () => navigateToRoute(route);
+  },
+});
+
+export default navigateToLimitRangesInjectable;

packages/core/src/common/front-end-routing/routes/cluster/config/pod-disruption-budgets/navigate-to-pod-disruption-budgets.injectable.ts

@@ -0,0 +1,20 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import podDisruptionBudgetsRouteInjectable from "./pod-disruption-budgets-route.injectable";
+import { navigateToRouteInjectionToken } from "../../../../navigate-to-route-injection-token";
+
+const navigateToPodDisruptionBudgetsInjectable = getInjectable({
+  id: "navigate-to-pod-disruption-budgets",
+
+  instantiate: (di) => {
+    const navigateToRoute = di.inject(navigateToRouteInjectionToken);
+    const route = di.inject(podDisruptionBudgetsRouteInjectable);
+
+    return () => navigateToRoute(route);
+  },
+});
+
+export default navigateToPodDisruptionBudgetsInjectable;

packages/core/src/common/front-end-routing/routes/cluster/config/pod-disruption-budgets/pod-disruption-budgets-route.injectable.ts

@@ -0,0 +1,24 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import { shouldShowResourceInjectionToken } from "../../../../../cluster-store/allowed-resources-injection-token";
+import { frontEndRouteInjectionToken } from "../../../../front-end-route-injection-token";
+
+const podDisruptionBudgetsRouteInjectable = getInjectable({
+  id: "pod-disruption-budgets-route",
+
+  instantiate: (di) => ({
+    path: "/poddisruptionbudgets",
+    clusterFrame: true,
+    isEnabled: di.inject(shouldShowResourceInjectionToken, {
+      apiName: "poddisruptionbudgets",
+      group: "policy",
+    }),
+  }),
+
+  injectionToken: frontEndRouteInjectionToken,
+});
+
+export default podDisruptionBudgetsRouteInjectable;

packages/core/src/common/front-end-routing/routes/cluster/config/priority-classes/navigate-to-priority-classes.injectable.ts

@@ -0,0 +1,20 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import priorityClassesRouteInjectable from "./priority-classes-route.injectable";
+import { navigateToRouteInjectionToken } from "../../../../navigate-to-route-injection-token";
+
+const navigateToPriorityClassesInjectable = getInjectable({
+  id: "navigate-to-priority-classes",
+
+  instantiate: (di) => {
+    const navigateToRoute = di.inject(navigateToRouteInjectionToken);
+    const route = di.inject(priorityClassesRouteInjectable);
+
+    return () => navigateToRoute(route);
+  },
+});
+
+export default navigateToPriorityClassesInjectable;

packages/core/src/common/front-end-routing/routes/cluster/config/priority-classes/priority-classes-route.injectable.ts

@@ -0,0 +1,24 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import { shouldShowResourceInjectionToken } from "../../../../../cluster-store/allowed-resources-injection-token";
+import { frontEndRouteInjectionToken } from "../../../../front-end-route-injection-token";
+
+const priorityClassesRouteInjectable = getInjectable({
+  id: "priority-classes-route",
+
+  instantiate: (di) => ({
+    path: "/priorityclasses",
+    clusterFrame: true,
+    isEnabled: di.inject(shouldShowResourceInjectionToken, {
+      apiName: "priorityclasses",
+      group: "scheduling.k8s.io",
+    }),
+  }),
+
+  injectionToken: frontEndRouteInjectionToken,
+});
+
+export default priorityClassesRouteInjectable;

packages/core/src/common/front-end-routing/routes/cluster/config/resource-quotas/navigate-to-resource-quotas.injectable.ts

@@ -0,0 +1,20 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import resourceQuotasRouteInjectable from "./resource-quotas-route.injectable";
+import { navigateToRouteInjectionToken } from "../../../../navigate-to-route-injection-token";
+
+const navigateToResourceQuotasInjectable = getInjectable({
+  id: "navigate-to-resource-quotas",
+
+  instantiate: (di) => {
+    const navigateToRoute = di.inject(navigateToRouteInjectionToken);
+    const route = di.inject(resourceQuotasRouteInjectable);
+
+    return () => navigateToRoute(route);
+  },
+});
+
+export default navigateToResourceQuotasInjectable;

packages/core/src/common/front-end-routing/routes/cluster/config/resource-quotas/resource-quotas-route.injectable.ts

@@ -0,0 +1,24 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import { shouldShowResourceInjectionToken } from "../../../../../cluster-store/allowed-resources-injection-token";
+import { frontEndRouteInjectionToken } from "../../../../front-end-route-injection-token";
+
+const resourceQuotasRouteInjectable = getInjectable({
+  id: "resource-quotas-route",
+
+  instantiate: (di) => ({
+    path: "/resourcequotas",
+    clusterFrame: true,
+    isEnabled: di.inject(shouldShowResourceInjectionToken, {
+      apiName: "resourcequotas",
+      group: "",
+    }),
+  }),
+
+  injectionToken: frontEndRouteInjectionToken,
+});
+
+export default resourceQuotasRouteInjectable;

packages/core/src/common/front-end-routing/routes/cluster/config/runtime-classes/navigate-to-runtime-classes.injectable.ts

@@ -0,0 +1,20 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import runtimeClassesRouteInjectable from "./runtime-classes-route.injectable";
+import { navigateToRouteInjectionToken } from "../../../../navigate-to-route-injection-token";
+
+const navigateToRuntimeClassesInjectable = getInjectable({
+  id: "navigate-to-runtime-classes",
+
+  instantiate: (di) => {
+    const navigateToRoute = di.inject(navigateToRouteInjectionToken);
+    const route = di.inject(runtimeClassesRouteInjectable);
+
+    return () => navigateToRoute(route);
+  },
+});
+
+export default navigateToRuntimeClassesInjectable;

packages/core/src/common/front-end-routing/routes/cluster/config/runtime-classes/runtime-classes-route.injectable.ts

@@ -0,0 +1,24 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import { shouldShowResourceInjectionToken } from "../../../../../cluster-store/allowed-resources-injection-token";
+import { frontEndRouteInjectionToken } from "../../../../front-end-route-injection-token";
+
+const runtimeClassesRouteInjectable = getInjectable({
+  id: "runtime-classes-route",
+
+  instantiate: (di) => ({
+    path: "/runtimeclasses",
+    clusterFrame: true,
+    isEnabled: di.inject(shouldShowResourceInjectionToken, {
+      apiName: "runtimeclasses",
+      group: "node.k8s.io",
+    }),
+  }),
+
+  injectionToken: frontEndRouteInjectionToken,
+});
+
+export default runtimeClassesRouteInjectable;

packages/core/src/common/front-end-routing/routes/cluster/config/secrets/navigate-to-secrets.injectable.ts

@@ -0,0 +1,20 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import secretsRouteInjectable from "./secrets-route.injectable";
+import { navigateToRouteInjectionToken } from "../../../../navigate-to-route-injection-token";
+
+const navigateToSecretsInjectable = getInjectable({
+  id: "navigate-to-secrets",
+
+  instantiate: (di) => {
+    const navigateToRoute = di.inject(navigateToRouteInjectionToken);
+    const route = di.inject(secretsRouteInjectable);
+
+    return () => navigateToRoute(route);
+  },
+});
+
+export default navigateToSecretsInjectable;

packages/core/src/common/front-end-routing/routes/cluster/config/secrets/secrets-route.injectable.ts

@@ -0,0 +1,24 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import { shouldShowResourceInjectionToken } from "../../../../../cluster-store/allowed-resources-injection-token";
+import { frontEndRouteInjectionToken } from "../../../../front-end-route-injection-token";
+
+const secretsRouteInjectable = getInjectable({
+  id: "secrets-route",
+
+  instantiate: (di) => ({
+    path: "/secrets",
+    clusterFrame: true,
+    isEnabled: di.inject(shouldShowResourceInjectionToken, {
+      apiName: "secrets",
+      group: "",
+    }),
+  }),
+
+  injectionToken: frontEndRouteInjectionToken,
+});
+
+export default secretsRouteInjectable;

packages/core/src/common/front-end-routing/routes/cluster/custom-resources/crd-list/crd-list-route.injectable.ts

@@ -0,0 +1,21 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import { computed } from "mobx";
+import { frontEndRouteInjectionToken } from "../../../../front-end-route-injection-token";
+
+const crdListRouteInjectable = getInjectable({
+  id: "crd-list-route",
+
+  instantiate: () => ({
+    path: "/crd/definitions",
+    clusterFrame: true,
+    isEnabled: computed(() => true),
+  }),
+
+  injectionToken: frontEndRouteInjectionToken,
+});
+
+export default crdListRouteInjectable;

packages/core/src/common/front-end-routing/routes/cluster/custom-resources/crd-list/navigate-to-crd-list.injectable.ts

@@ -0,0 +1,20 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import crdListRouteInjectable from "./crd-list-route.injectable";
+import { navigateToRouteInjectionToken } from "../../../../navigate-to-route-injection-token";
+
+const navigateToCrdListInjectable = getInjectable({
+  id: "navigate-to-crd-list",
+
+  instantiate: (di) => {
+    const navigateToRoute = di.inject(navigateToRouteInjectionToken);
+    const route = di.inject(crdListRouteInjectable);
+
+    return () => navigateToRoute(route);
+  },
+});
+
+export default navigateToCrdListInjectable;

packages/core/src/common/front-end-routing/routes/cluster/custom-resources/custom-resources/custom-resources-route.injectable.ts

@@ -0,0 +1,27 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import { computed } from "mobx";
+import type { Route } from "../../../../front-end-route-injection-token";
+import { frontEndRouteInjectionToken } from "../../../../front-end-route-injection-token";
+
+export interface CustomResourcesPathParameters {
+  group?: string;
+  name?: string;
+}
+
+const customResourcesRouteInjectable = getInjectable({
+  id: "custom-resources-route",
+
+  instantiate: (): Route<CustomResourcesPathParameters> => ({
+    path: "/crd/:group?/:name?",
+    clusterFrame: true,
+    isEnabled: computed(() => true),
+  }),
+
+  injectionToken: frontEndRouteInjectionToken,
+});
+
+export default customResourcesRouteInjectable;

packages/core/src/common/front-end-routing/routes/cluster/custom-resources/custom-resources/navigate-to-custom-resources.injectable.ts

@@ -0,0 +1,22 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import type { CustomResourcesPathParameters } from "./custom-resources-route.injectable";
+import customResourcesRouteInjectable from "./custom-resources-route.injectable";
+import { navigateToRouteInjectionToken } from "../../../../navigate-to-route-injection-token";
+
+const navigateToCustomResourcesInjectable = getInjectable({
+  id: "navigate-to-custom-resources",
+
+  instantiate: (di) => {
+    const navigateToRoute = di.inject(navigateToRouteInjectionToken);
+    const route = di.inject(customResourcesRouteInjectable);
+
+    return (parameters?: CustomResourcesPathParameters) =>
+      navigateToRoute(route, { parameters });
+  },
+});
+
+export default navigateToCustomResourcesInjectable;

packages/core/src/common/front-end-routing/routes/cluster/events/events-route.injectable.ts

@@ -0,0 +1,24 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import { shouldShowResourceInjectionToken } from "../../../../cluster-store/allowed-resources-injection-token";
+import { frontEndRouteInjectionToken } from "../../../front-end-route-injection-token";
+
+const eventsRouteInjectable = getInjectable({
+  id: "events-route",
+
+  instantiate: (di) => ({
+    path: "/events",
+    clusterFrame: true,
+    isEnabled: di.inject(shouldShowResourceInjectionToken, {
+      apiName: "events",
+      group: "",
+    }),
+  }),
+
+  injectionToken: frontEndRouteInjectionToken,
+});
+
+export default eventsRouteInjectable;

packages/core/src/common/front-end-routing/routes/cluster/events/navigate-to-events.injectable.ts

@@ -0,0 +1,20 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import eventsRouteInjectable from "./events-route.injectable";
+import { navigateToRouteInjectionToken } from "../../../navigate-to-route-injection-token";
+
+const navigateToEventsInjectable = getInjectable({
+  id: "navigate-to-events",
+
+  instantiate: (di) => {
+    const navigateToRoute = di.inject(navigateToRouteInjectionToken);
+    const route = di.inject(eventsRouteInjectable);
+
+    return () => navigateToRoute(route);
+  },
+});
+
+export default navigateToEventsInjectable;

packages/core/src/common/front-end-routing/routes/cluster/helm/charts/helm-charts-route.injectable.ts

@@ -0,0 +1,27 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import { computed } from "mobx";
+import type { Route } from "../../../../front-end-route-injection-token";
+import { frontEndRouteInjectionToken } from "../../../../front-end-route-injection-token";
+
+export interface HelmChartsPathParameters {
+  repo?: string;
+  chartName?: string;
+}
+
+const helmChartsRouteInjectable = getInjectable({
+  id: "helm-charts-route",
+
+  instantiate: (): Route<HelmChartsPathParameters> => ({
+    path: "/helm/charts/:repo?/:chartName?",
+    clusterFrame: true,
+    isEnabled: computed(() => true),
+  }),
+
+  injectionToken: frontEndRouteInjectionToken,
+});
+
+export default helmChartsRouteInjectable;

packages/core/src/common/front-end-routing/routes/cluster/helm/charts/navigate-to-helm-charts.injectable.ts

@@ -0,0 +1,26 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import type { HelmChartsPathParameters } from "./helm-charts-route.injectable";
+import helmChartsRouteInjectable from "./helm-charts-route.injectable";
+import { navigateToRouteInjectionToken } from "../../../../navigate-to-route-injection-token";
+
+export type NavigateToHelmCharts = (parameters?: HelmChartsPathParameters) => void;
+
+const navigateToHelmChartsInjectable = getInjectable({
+  id: "navigate-to-helm-charts",
+
+  instantiate: (di): NavigateToHelmCharts => {
+    const navigateToRoute = di.inject(navigateToRouteInjectionToken);
+    const route = di.inject(helmChartsRouteInjectable);
+
+    return (parameters) =>
+      navigateToRoute(route, {
+        parameters,
+      });
+  },
+});
+
+export default navigateToHelmChartsInjectable;

packages/core/src/common/front-end-routing/routes/cluster/helm/releases/helm-releases-route.injectable.ts

@@ -0,0 +1,27 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import { computed } from "mobx";
+import type { Route } from "../../../../front-end-route-injection-token";
+import { frontEndRouteInjectionToken } from "../../../../front-end-route-injection-token";
+
+export interface HelmReleasesPathParameters {
+  namespace?: string;
+  name?: string;
+}
+
+const helmReleasesRouteInjectable = getInjectable({
+  id: "helm-releases-route",
+
+  instantiate: (): Route<HelmReleasesPathParameters> => ({
+    path: "/helm/releases/:namespace?/:name?",
+    clusterFrame: true,
+    isEnabled: computed(() => true),
+  }),
+
+  injectionToken: frontEndRouteInjectionToken,
+});
+
+export default helmReleasesRouteInjectable;

packages/core/src/common/front-end-routing/routes/cluster/helm/releases/navigate-to-helm-releases.injectable.ts

@@ -0,0 +1,23 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import type { HelmReleasesPathParameters } from "./helm-releases-route.injectable";
+import helmReleasesRouteInjectable from "./helm-releases-route.injectable";
+import { navigateToRouteInjectionToken } from "../../../../navigate-to-route-injection-token";
+
+export type NavigateToHelmReleases = (parameters?: HelmReleasesPathParameters) => void;
+
+const navigateToHelmReleasesInjectable = getInjectable({
+  id: "navigate-to-helm-releases",
+
+  instantiate: (di): NavigateToHelmReleases => {
+    const navigateToRoute = di.inject(navigateToRouteInjectionToken);
+    const route = di.inject(helmReleasesRouteInjectable);
+
+    return (parameters) => navigateToRoute(route, { parameters });
+  },
+});
+
+export default navigateToHelmReleasesInjectable;

packages/core/src/common/front-end-routing/routes/cluster/namespaces/namespaces-route.injectable.ts

@@ -0,0 +1,24 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import { shouldShowResourceInjectionToken } from "../../../../cluster-store/allowed-resources-injection-token";
+import { frontEndRouteInjectionToken } from "../../../front-end-route-injection-token";
+
+const namespacesRouteInjectable = getInjectable({
+  id: "namespaces-route",
+
+  instantiate: (di) => ({
+    path: "/namespaces",
+    clusterFrame: true,
+    isEnabled: di.inject(shouldShowResourceInjectionToken, {
+      apiName: "namespaces",
+      group: "",
+    }),
+  }),
+
+  injectionToken: frontEndRouteInjectionToken,
+});
+
+export default namespacesRouteInjectable;

packages/core/src/common/front-end-routing/routes/cluster/namespaces/navigate-to-namespaces.injectable.ts

@@ -0,0 +1,20 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import namespacesRouteInjectable from "./namespaces-route.injectable";
+import { navigateToRouteInjectionToken } from "../../../navigate-to-route-injection-token";
+
+const navigateToNamespacesInjectable = getInjectable({
+  id: "navigate-to-namespaces",
+
+  instantiate: (di) => {
+    const navigateToRoute = di.inject(navigateToRouteInjectionToken);
+    const route = di.inject(namespacesRouteInjectable);
+
+    return () => navigateToRoute(route);
+  },
+});
+
+export default navigateToNamespacesInjectable;

packages/core/src/common/front-end-routing/routes/cluster/network/endpoints/endpoints-route.injectable.ts

@@ -0,0 +1,24 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import { shouldShowResourceInjectionToken } from "../../../../../cluster-store/allowed-resources-injection-token";
+import { frontEndRouteInjectionToken } from "../../../../front-end-route-injection-token";
+
+const endpointsRouteInjectable = getInjectable({
+  id: "endpoints-route",
+
+  instantiate: (di) => ({
+    path: "/endpoints",
+    clusterFrame: true,
+    isEnabled: di.inject(shouldShowResourceInjectionToken, {
+      apiName: "endpoints",
+      group: "",
+    }),
+  }),
+
+  injectionToken: frontEndRouteInjectionToken,
+});
+
+export default endpointsRouteInjectable;

packages/core/src/common/front-end-routing/routes/cluster/network/endpoints/navigate-to-endpoints.injectable.ts

@@ -0,0 +1,20 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import endpointsRouteInjectable from "./endpoints-route.injectable";
+import { navigateToRouteInjectionToken } from "../../../../navigate-to-route-injection-token";
+
+const navigateToEndpointsInjectable = getInjectable({
+  id: "navigate-to-endpoints",
+
+  instantiate: (di) => {
+    const navigateToRoute = di.inject(navigateToRouteInjectionToken);
+    const route = di.inject(endpointsRouteInjectable);
+
+    return () => navigateToRoute(route);
+  },
+});
+
+export default navigateToEndpointsInjectable;

packages/core/src/common/front-end-routing/routes/cluster/network/ingress-class/ingress-classeses-route.injectable.ts

@@ -0,0 +1,30 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import { frontEndRouteInjectionToken } from "../../../../front-end-route-injection-token";
+import {
+  shouldShowResourceInjectionToken,
+} from "../../../../../cluster-store/allowed-resources-injection-token";
+
+const ingressClassesesRouteInjectable = getInjectable({
+  id: "ingress-classes-route",
+
+  instantiate: (di) => {
+    const isEnabled = di.inject(shouldShowResourceInjectionToken, {
+      apiName: "ingressclasses",
+      group: "networking.k8s.io",
+    });
+
+    return {
+      path: "/ingress-classes",
+      clusterFrame: true,
+      isEnabled,
+    };
+  },
+
+  injectionToken: frontEndRouteInjectionToken,
+});
+
+export default ingressClassesesRouteInjectable;

packages/core/src/common/front-end-routing/routes/cluster/network/ingress-class/navigate-to-ingress-classes.injectable.ts

@@ -0,0 +1,20 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import { navigateToRouteInjectionToken } from "../../../../navigate-to-route-injection-token";
+import ingressClassesesRouteInjectable from "./ingress-classeses-route.injectable";
+
+const navigateToIngressesInjectable = getInjectable({
+  id: "navigate-to-ingress-classes",
+
+  instantiate: (di) => {
+    const navigateToRoute = di.inject(navigateToRouteInjectionToken);
+    const route = di.inject(ingressClassesesRouteInjectable);
+
+    return () => navigateToRoute(route);
+  },
+});
+
+export default navigateToIngressesInjectable;

packages/core/src/common/front-end-routing/routes/cluster/network/ingresses/ingresses-route.injectable.ts

@@ -0,0 +1,31 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import { shouldShowResourceInjectionToken } from "../../../../../cluster-store/allowed-resources-injection-token";
+import { computedOr } from "../../../../../utils/computed-or";
+import { frontEndRouteInjectionToken } from "../../../../front-end-route-injection-token";
+
+const ingressesRouteInjectable = getInjectable({
+  id: "ingresses-route",
+
+  instantiate: (di) => ({
+    path: "/ingresses",
+    clusterFrame: true,
+    isEnabled: computedOr(
+      di.inject(shouldShowResourceInjectionToken, {
+        apiName: "ingresses",
+        group: "networking.k8s.io",
+      }),
+      di.inject(shouldShowResourceInjectionToken, {
+        apiName: "ingresses",
+        group: "extensions",
+      }),
+    ),
+  }),
+
+  injectionToken: frontEndRouteInjectionToken,
+});
+
+export default ingressesRouteInjectable;

packages/core/src/common/front-end-routing/routes/cluster/network/ingresses/navigate-to-ingresses.injectable.ts

@@ -0,0 +1,20 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import ingressesRouteInjectable from "./ingresses-route.injectable";
+import { navigateToRouteInjectionToken } from "../../../../navigate-to-route-injection-token";
+
+const navigateToIngressesInjectable = getInjectable({
+  id: "navigate-to-ingresses",
+
+  instantiate: (di) => {
+    const navigateToRoute = di.inject(navigateToRouteInjectionToken);
+    const route = di.inject(ingressesRouteInjectable);
+
+    return () => navigateToRoute(route);
+  },
+});
+
+export default navigateToIngressesInjectable;

packages/core/src/common/front-end-routing/routes/cluster/network/network-policies/navigate-to-network-policies.injectable.ts

@@ -0,0 +1,20 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import networkPoliciesRouteInjectable from "./network-policies-route.injectable";
+import { navigateToRouteInjectionToken } from "../../../../navigate-to-route-injection-token";
+
+const navigateToNetworkPoliciesInjectable = getInjectable({
+  id: "navigate-to-network-policies",
+
+  instantiate: (di) => {
+    const navigateToRoute = di.inject(navigateToRouteInjectionToken);
+    const route = di.inject(networkPoliciesRouteInjectable);
+
+    return () => navigateToRoute(route);
+  },
+});
+
+export default navigateToNetworkPoliciesInjectable;

packages/core/src/common/front-end-routing/routes/cluster/network/network-policies/network-policies-route.injectable.ts

@@ -0,0 +1,24 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import { shouldShowResourceInjectionToken } from "../../../../../cluster-store/allowed-resources-injection-token";
+import { frontEndRouteInjectionToken } from "../../../../front-end-route-injection-token";
+
+const networkPoliciesRouteInjectable = getInjectable({
+  id: "network-policies-route",
+
+  instantiate: (di) => ({
+    path: "/network-policies",
+    clusterFrame: true,
+    isEnabled: di.inject(shouldShowResourceInjectionToken, {
+      apiName: "networkpolicies",
+      group: "networking.k8s.io",
+    }),
+  }),
+
+  injectionToken: frontEndRouteInjectionToken,
+});
+
+export default networkPoliciesRouteInjectable;

packages/core/src/common/front-end-routing/routes/cluster/network/port-forwards/navigate-to-port-forwards.injectable.ts

@@ -0,0 +1,24 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import type { PortForwardsPathParameters } from "./port-forwards-route.injectable";
+import portForwardsRouteInjectable from "./port-forwards-route.injectable";
+import { navigateToRouteInjectionToken } from "../../../../navigate-to-route-injection-token";
+
+export type NavigateToPortForwards = (parameters?: PortForwardsPathParameters) => void;
+
+const navigateToPortForwardsInjectable = getInjectable({
+  id: "navigate-to-port-forwards",
+
+  instantiate: (di): NavigateToPortForwards => {
+    const navigateToRoute = di.inject(navigateToRouteInjectionToken);
+    const route = di.inject(portForwardsRouteInjectable);
+
+    return (parameters) =>
+      navigateToRoute(route, { parameters });
+  },
+});
+
+export default navigateToPortForwardsInjectable;

packages/core/src/common/front-end-routing/routes/cluster/network/port-forwards/port-forwards-route.injectable.ts

@@ -0,0 +1,26 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import { computed } from "mobx";
+import type { Route } from "../../../../front-end-route-injection-token";
+import { frontEndRouteInjectionToken } from "../../../../front-end-route-injection-token";
+
+export interface PortForwardsPathParameters {
+  forwardport?: string;
+}
+
+const portForwardsRouteInjectable = getInjectable({
+  id: "port-forwards-route",
+
+  instantiate: (): Route<PortForwardsPathParameters> => ({
+    path: "/port-forwards/:forwardport?",
+    clusterFrame: true,
+    isEnabled: computed(() => true),
+  }),
+
+  injectionToken: frontEndRouteInjectionToken,
+});
+
+export default portForwardsRouteInjectable;

packages/core/src/common/front-end-routing/routes/cluster/network/services/navigate-to-services.injectable.ts

@@ -0,0 +1,20 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import servicesRouteInjectable from "./services-route.injectable";
+import { navigateToRouteInjectionToken } from "../../../../navigate-to-route-injection-token";
+
+const navigateToServicesInjectable = getInjectable({
+  id: "navigate-to-services",
+
+  instantiate: (di) => {
+    const navigateToRoute = di.inject(navigateToRouteInjectionToken);
+    const route = di.inject(servicesRouteInjectable);
+
+    return () => navigateToRoute(route);
+  },
+});
+
+export default navigateToServicesInjectable;

packages/core/src/common/front-end-routing/routes/cluster/network/services/services-route.injectable.ts

@@ -0,0 +1,24 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import { shouldShowResourceInjectionToken } from "../../../../../cluster-store/allowed-resources-injection-token";
+import { frontEndRouteInjectionToken } from "../../../../front-end-route-injection-token";
+
+const servicesRouteInjectable = getInjectable({
+  id: "services-route",
+
+  instantiate: (di) => ({
+    path: "/services",
+    clusterFrame: true,
+    isEnabled: di.inject(shouldShowResourceInjectionToken, {
+      apiName: "services",
+      group: "",
+    }),
+  }),
+
+  injectionToken: frontEndRouteInjectionToken,
+});
+
+export default servicesRouteInjectable;

packages/core/src/common/front-end-routing/routes/cluster/nodes/navigate-to-nodes.injectable.ts

@@ -0,0 +1,20 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import nodesRouteInjectable from "./nodes-route.injectable";
+import { navigateToRouteInjectionToken } from "../../../navigate-to-route-injection-token";
+
+const navigateToNodesInjectable = getInjectable({
+  id: "navigate-to-nodes",
+
+  instantiate: (di) => {
+    const navigateToRoute = di.inject(navigateToRouteInjectionToken);
+    const route = di.inject(nodesRouteInjectable);
+
+    return () => navigateToRoute(route);
+  },
+});
+
+export default navigateToNodesInjectable;

packages/core/src/common/front-end-routing/routes/cluster/nodes/nodes-route.injectable.ts

@@ -0,0 +1,24 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import { shouldShowResourceInjectionToken } from "../../../../cluster-store/allowed-resources-injection-token";
+import { frontEndRouteInjectionToken } from "../../../front-end-route-injection-token";
+
+const nodesRouteInjectable = getInjectable({
+  id: "nodes-route",
+
+  instantiate: (di) => ({
+    path: "/nodes",
+    clusterFrame: true,
+    isEnabled: di.inject(shouldShowResourceInjectionToken, {
+      apiName: "nodes",
+      group: "",
+    }),
+  }),
+
+  injectionToken: frontEndRouteInjectionToken,
+});
+
+export default nodesRouteInjectable;

packages/core/src/common/front-end-routing/routes/cluster/overview/cluster-overview-route.injectable.ts

@@ -0,0 +1,24 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import { shouldShowResourceInjectionToken } from "../../../../cluster-store/allowed-resources-injection-token";
+import { frontEndRouteInjectionToken } from "../../../front-end-route-injection-token";
+
+const clusterOverviewRouteInjectable = getInjectable({
+  id: "cluster-overview-route",
+
+  instantiate: (di) => ({
+    path: "/overview",
+    clusterFrame: true,
+    isEnabled: di.inject(shouldShowResourceInjectionToken, {
+      apiName: "nodes",
+      group: "",
+    }),
+  }),
+
+  injectionToken: frontEndRouteInjectionToken,
+});
+
+export default clusterOverviewRouteInjectable;

packages/core/src/common/front-end-routing/routes/cluster/overview/navigate-to-cluster-overview.injectable.ts

@@ -0,0 +1,20 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import clusterOverviewRouteInjectable from "./cluster-overview-route.injectable";
+import { navigateToRouteInjectionToken } from "../../../navigate-to-route-injection-token";
+
+const navigateToClusterOverviewInjectable = getInjectable({
+  id: "navigate-to-cluster-overview",
+
+  instantiate: (di) => {
+    const navigateToRoute = di.inject(navigateToRouteInjectionToken);
+    const route = di.inject(clusterOverviewRouteInjectable);
+
+    return () => navigateToRoute(route);
+  },
+});
+
+export default navigateToClusterOverviewInjectable;

packages/core/src/common/front-end-routing/routes/cluster/storage/persistent-volume-claims/navigate-to-persistent-volume-claims.injectable.ts

@@ -0,0 +1,20 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import persistentVolumeClaimsRouteInjectable from "./persistent-volume-claims-route.injectable";
+import { navigateToRouteInjectionToken } from "../../../../navigate-to-route-injection-token";
+
+const navigateToPersistentVolumeClaimsInjectable = getInjectable({
+  id: "navigate-to-persistent-volume-claims",
+
+  instantiate: (di) => {
+    const navigateToRoute = di.inject(navigateToRouteInjectionToken);
+    const route = di.inject(persistentVolumeClaimsRouteInjectable);
+
+    return () => navigateToRoute(route);
+  },
+});
+
+export default navigateToPersistentVolumeClaimsInjectable;

packages/core/src/common/front-end-routing/routes/cluster/storage/persistent-volume-claims/persistent-volume-claims-route.injectable.ts

@@ -0,0 +1,24 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import { shouldShowResourceInjectionToken } from "../../../../../cluster-store/allowed-resources-injection-token";
+import { frontEndRouteInjectionToken } from "../../../../front-end-route-injection-token";
+
+const persistentVolumeClaimsRouteInjectable = getInjectable({
+  id: "persistent-volume-claims-route",
+
+  instantiate: (di) => ({
+    path: "/persistent-volume-claims",
+    clusterFrame: true,
+    isEnabled: di.inject(shouldShowResourceInjectionToken, {
+      apiName: "persistentvolumeclaims",
+      group: "",
+    }),
+  }),
+
+  injectionToken: frontEndRouteInjectionToken,
+});
+
+export default persistentVolumeClaimsRouteInjectable;

packages/core/src/common/front-end-routing/routes/cluster/storage/persistent-volumes/navigate-to-persistent-volumes.injectable.ts

@@ -0,0 +1,20 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import persistentVolumesRouteInjectable from "./persistent-volumes-route.injectable";
+import { navigateToRouteInjectionToken } from "../../../../navigate-to-route-injection-token";
+
+const navigateToPersistentVolumesInjectable = getInjectable({
+  id: "navigate-to-persistent-volumes",
+
+  instantiate: (di) => {
+    const navigateToRoute = di.inject(navigateToRouteInjectionToken);
+    const route = di.inject(persistentVolumesRouteInjectable);
+
+    return () => navigateToRoute(route);
+  },
+});
+
+export default navigateToPersistentVolumesInjectable;

packages/core/src/common/front-end-routing/routes/cluster/storage/persistent-volumes/persistent-volumes-route.injectable.ts

@@ -0,0 +1,24 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import { shouldShowResourceInjectionToken } from "../../../../../cluster-store/allowed-resources-injection-token";
+import { frontEndRouteInjectionToken } from "../../../../front-end-route-injection-token";
+
+const persistentVolumesRouteInjectable = getInjectable({
+  id: "persistent-volumes-route",
+
+  instantiate: (di) => ({
+    path: "/persistent-volumes",
+    clusterFrame: true,
+    isEnabled: di.inject(shouldShowResourceInjectionToken, {
+      apiName: "persistentvolumes",
+      group: "",
+    }),
+  }),
+
+  injectionToken: frontEndRouteInjectionToken,
+});
+
+export default persistentVolumesRouteInjectable;

packages/core/src/common/front-end-routing/routes/cluster/storage/storage-classes/navigate-to-storage-classes.injectable.ts

@@ -0,0 +1,20 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import storageClassesRouteInjectable from "./storage-classes-route.injectable";
+import { navigateToRouteInjectionToken } from "../../../../navigate-to-route-injection-token";
+
+const navigateToStorageClassesInjectable = getInjectable({
+  id: "navigate-to-storage-classes",
+
+  instantiate: (di) => {
+    const navigateToRoute = di.inject(navigateToRouteInjectionToken);
+    const route = di.inject(storageClassesRouteInjectable);
+
+    return () => navigateToRoute(route);
+  },
+});
+
+export default navigateToStorageClassesInjectable;

packages/core/src/common/front-end-routing/routes/cluster/storage/storage-classes/storage-classes-route.injectable.ts

@@ -0,0 +1,24 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import { shouldShowResourceInjectionToken } from "../../../../../cluster-store/allowed-resources-injection-token";
+import { frontEndRouteInjectionToken } from "../../../../front-end-route-injection-token";
+
+const storageClassesRouteInjectable = getInjectable({
+  id: "storage-classes-route",
+
+  instantiate: (di) => ({
+    path: "/storage-classes",
+    clusterFrame: true,
+    isEnabled: di.inject(shouldShowResourceInjectionToken, {
+      apiName: "storageclasses",
+      group: "storage.k8s.io",
+    }),
+  }),
+
+  injectionToken: frontEndRouteInjectionToken,
+});
+
+export default storageClassesRouteInjectable;

packages/core/src/common/front-end-routing/routes/cluster/user-management/cluster-role-bindings/cluster-role-bindings-route.injectable.ts

@@ -0,0 +1,24 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import { shouldShowResourceInjectionToken } from "../../../../../cluster-store/allowed-resources-injection-token";
+import { frontEndRouteInjectionToken } from "../../../../front-end-route-injection-token";
+
+const clusterRoleBindingsRouteInjectable = getInjectable({
+  id: "cluster-role-bindings-route",
+
+  instantiate: (di) => ({
+    path: "/cluster-role-bindings",
+    clusterFrame: true,
+    isEnabled: di.inject(shouldShowResourceInjectionToken, {
+      apiName: "clusterrolebindings",
+      group: "rbac.authorization.k8s.io",
+    }),
+  }),
+
+  injectionToken: frontEndRouteInjectionToken,
+});
+
+export default clusterRoleBindingsRouteInjectable;

packages/core/src/common/front-end-routing/routes/cluster/user-management/cluster-role-bindings/navigate-to-cluster-role-bindings.injectable.ts

@@ -0,0 +1,20 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import clusterRoleBindingsRouteInjectable from "./cluster-role-bindings-route.injectable";
+import { navigateToRouteInjectionToken } from "../../../../navigate-to-route-injection-token";
+
+const navigateToClusterRoleBindingsInjectable = getInjectable({
+  id: "navigate-to-cluster-role-bindings",
+
+  instantiate: (di) => {
+    const navigateToRoute = di.inject(navigateToRouteInjectionToken);
+    const route = di.inject(clusterRoleBindingsRouteInjectable);
+
+    return () => navigateToRoute(route);
+  },
+});
+
+export default navigateToClusterRoleBindingsInjectable;

packages/core/src/common/front-end-routing/routes/cluster/user-management/cluster-roles/cluster-roles-route.injectable.ts

@@ -0,0 +1,24 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import { shouldShowResourceInjectionToken } from "../../../../../cluster-store/allowed-resources-injection-token";
+import { frontEndRouteInjectionToken } from "../../../../front-end-route-injection-token";
+
+const clusterRolesRouteInjectable = getInjectable({
+  id: "cluster-roles-route",
+
+  instantiate: (di) => ({
+    path: "/cluster-roles",
+    clusterFrame: true,
+    isEnabled: di.inject(shouldShowResourceInjectionToken, {
+      apiName: "clusterroles",
+      group: "rbac.authorization.k8s.io",
+    }),
+  }),
+
+  injectionToken: frontEndRouteInjectionToken,
+});
+
+export default clusterRolesRouteInjectable;

packages/core/src/common/front-end-routing/routes/cluster/user-management/cluster-roles/navigate-to-cluster-roles.injectable.ts

@@ -0,0 +1,20 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import clusterRolesRouteInjectable from "./cluster-roles-route.injectable";
+import { navigateToRouteInjectionToken } from "../../../../navigate-to-route-injection-token";
+
+const navigateToClusterRolesInjectable = getInjectable({
+  id: "navigate-to-cluster-roles",
+
+  instantiate: (di) => {
+    const navigateToRoute = di.inject(navigateToRouteInjectionToken);
+    const route = di.inject(clusterRolesRouteInjectable);
+
+    return () => navigateToRoute(route);
+  },
+});
+
+export default navigateToClusterRolesInjectable;

packages/core/src/common/front-end-routing/routes/cluster/user-management/pod-security-policies/navigate-to-pod-security-policies.injectable.ts

@@ -0,0 +1,20 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import podSecurityPoliciesRouteInjectable from "./pod-security-policies-route.injectable";
+import { navigateToRouteInjectionToken } from "../../../../navigate-to-route-injection-token";
+
+const navigateToPodSecurityPoliciesInjectable = getInjectable({
+  id: "navigate-to-pod-security-policies",
+
+  instantiate: (di) => {
+    const navigateToRoute = di.inject(navigateToRouteInjectionToken);
+    const route = di.inject(podSecurityPoliciesRouteInjectable);
+
+    return () => navigateToRoute(route);
+  },
+});
+
+export default navigateToPodSecurityPoliciesInjectable;

packages/core/src/common/front-end-routing/routes/cluster/user-management/pod-security-policies/pod-security-policies-route.injectable.ts

@@ -0,0 +1,26 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import { shouldShowResourceInjectionToken } from "../../../../../cluster-store/allowed-resources-injection-token";
+import { frontEndRouteInjectionToken } from "../../../../front-end-route-injection-token";
+
+const podSecurityPoliciesRouteInjectable = getInjectable({
+  id: "pod-security-policies-route",
+
+  instantiate: (di) => {
+    return {
+      path: "/pod-security-policies",
+      clusterFrame: true,
+      isEnabled: di.inject(shouldShowResourceInjectionToken, {
+        apiName: "podsecuritypolicies",
+        group: "policy",
+      }),
+    };
+  },
+
+  injectionToken: frontEndRouteInjectionToken,
+});
+
+export default podSecurityPoliciesRouteInjectable;

packages/core/src/common/front-end-routing/routes/cluster/user-management/role-bindings/navigate-to-role-bindings.injectable.ts

@@ -0,0 +1,20 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import roleBindingsRouteInjectable from "./role-bindings-route.injectable";
+import { navigateToRouteInjectionToken } from "../../../../navigate-to-route-injection-token";
+
+const navigateToRoleBindingsInjectable = getInjectable({
+  id: "navigate-to-role-bindings",
+
+  instantiate: (di) => {
+    const navigateToRoute = di.inject(navigateToRouteInjectionToken);
+    const route = di.inject(roleBindingsRouteInjectable);
+
+    return () => navigateToRoute(route);
+  },
+});
+
+export default navigateToRoleBindingsInjectable;

packages/core/src/common/front-end-routing/routes/cluster/user-management/role-bindings/role-bindings-route.injectable.ts

@@ -0,0 +1,26 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import { shouldShowResourceInjectionToken } from "../../../../../cluster-store/allowed-resources-injection-token";
+import { frontEndRouteInjectionToken } from "../../../../front-end-route-injection-token";
+
+const roleBindingsRouteInjectable = getInjectable({
+  id: "role-bindings-route",
+
+  instantiate: (di) => {
+    return {
+      path: "/role-bindings",
+      clusterFrame: true,
+      isEnabled: di.inject(shouldShowResourceInjectionToken, {
+        apiName: "rolebindings",
+        group: "rbac.authorization.k8s.io",
+      }),
+    };
+  },
+
+  injectionToken: frontEndRouteInjectionToken,
+});
+
+export default roleBindingsRouteInjectable;

packages/core/src/common/front-end-routing/routes/cluster/user-management/roles/navigate-to-roles.injectable.ts

@@ -0,0 +1,20 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import rolesRouteInjectable from "./roles-route.injectable";
+import { navigateToRouteInjectionToken } from "../../../../navigate-to-route-injection-token";
+
+const navigateToRolesInjectable = getInjectable({
+  id: "navigate-to-roles",
+
+  instantiate: (di) => {
+    const navigateToRoute = di.inject(navigateToRouteInjectionToken);
+    const route = di.inject(rolesRouteInjectable);
+
+    return () => navigateToRoute(route);
+  },
+});
+
+export default navigateToRolesInjectable;

packages/core/src/common/front-end-routing/routes/cluster/user-management/roles/roles-route.injectable.ts

@@ -0,0 +1,24 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import { shouldShowResourceInjectionToken } from "../../../../../cluster-store/allowed-resources-injection-token";
+import { frontEndRouteInjectionToken } from "../../../../front-end-route-injection-token";
+
+const rolesRouteInjectable = getInjectable({
+  id: "roles-route",
+
+  instantiate: (di) => ({
+    path: "/roles",
+    clusterFrame: true,
+    isEnabled: di.inject(shouldShowResourceInjectionToken, {
+      apiName: "roles",
+      group: "rbac.authorization.k8s.io",
+    }),
+  }),
+
+  injectionToken: frontEndRouteInjectionToken,
+});
+
+export default rolesRouteInjectable;

packages/core/src/common/front-end-routing/routes/cluster/user-management/service-accounts/navigate-to-service-accounts.injectable.ts

@@ -0,0 +1,20 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import serviceAccountsRouteInjectable from "./service-accounts-route.injectable";
+import { navigateToRouteInjectionToken } from "../../../../navigate-to-route-injection-token";
+
+const navigateToServiceAccountsInjectable = getInjectable({
+  id: "navigate-to-service-accounts",
+
+  instantiate: (di) => {
+    const navigateToRoute = di.inject(navigateToRouteInjectionToken);
+    const route = di.inject(serviceAccountsRouteInjectable);
+
+    return () => navigateToRoute(route);
+  },
+});
+
+export default navigateToServiceAccountsInjectable;

packages/core/src/common/front-end-routing/routes/cluster/user-management/service-accounts/service-accounts-route.injectable.ts

@@ -0,0 +1,24 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import { shouldShowResourceInjectionToken } from "../../../../../cluster-store/allowed-resources-injection-token";
+import { frontEndRouteInjectionToken } from "../../../../front-end-route-injection-token";
+
+const serviceAccountsRouteInjectable = getInjectable({
+  id: "service-accounts-route",
+
+  instantiate: (di) => ({
+    path: "/service-accounts",
+    clusterFrame: true,
+    isEnabled: di.inject(shouldShowResourceInjectionToken, {
+      apiName: "serviceaccounts",
+      group: "",
+    }),
+  }),
+
+  injectionToken: frontEndRouteInjectionToken,
+});
+
+export default serviceAccountsRouteInjectable;

packages/core/src/common/front-end-routing/routes/cluster/workloads/cron-jobs/cron-jobs-route.injectable.ts

@@ -0,0 +1,24 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import { shouldShowResourceInjectionToken } from "../../../../../cluster-store/allowed-resources-injection-token";
+import { frontEndRouteInjectionToken } from "../../../../front-end-route-injection-token";
+
+const cronJobsRouteInjectable = getInjectable({
+  id: "cron-jobs-route",
+
+  instantiate: (di) => ({
+    path: "/cronjobs",
+    clusterFrame: true,
+    isEnabled: di.inject(shouldShowResourceInjectionToken, {
+      apiName: "cronjobs",
+      group: "batch",
+    }),
+  }),
+
+  injectionToken: frontEndRouteInjectionToken,
+});
+
+export default cronJobsRouteInjectable;

packages/core/src/common/front-end-routing/routes/cluster/workloads/cron-jobs/navigate-to-cron-jobs.injectable.ts

@@ -0,0 +1,20 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import cronJobsRouteInjectable from "./cron-jobs-route.injectable";
+import { navigateToRouteInjectionToken } from "../../../../navigate-to-route-injection-token";
+
+const navigateToCronJobsInjectable = getInjectable({
+  id: "navigate-to-cron-jobs",
+
+  instantiate: (di) => {
+    const navigateToRoute = di.inject(navigateToRouteInjectionToken);
+    const route = di.inject(cronJobsRouteInjectable);
+
+    return () => navigateToRoute(route);
+  },
+});
+
+export default navigateToCronJobsInjectable;

packages/core/src/common/front-end-routing/routes/cluster/workloads/daemonsets/daemonsets-route.injectable.ts

@@ -0,0 +1,24 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import { shouldShowResourceInjectionToken } from "../../../../../cluster-store/allowed-resources-injection-token";
+import { frontEndRouteInjectionToken } from "../../../../front-end-route-injection-token";
+
+const daemonsetsRouteInjectable = getInjectable({
+  id: "daemonsets-route",
+
+  instantiate: (di) => ({
+    path: "/daemonsets",
+    clusterFrame: true,
+    isEnabled: di.inject(shouldShowResourceInjectionToken, {
+      apiName: "daemonsets",
+      group: "apps",
+    }),
+  }),
+
+  injectionToken: frontEndRouteInjectionToken,
+});
+
+export default daemonsetsRouteInjectable;

packages/core/src/common/front-end-routing/routes/cluster/workloads/daemonsets/navigate-to-daemonsets.injectable.ts

@@ -0,0 +1,20 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import daemonsetsRouteInjectable from "./daemonsets-route.injectable";
+import { navigateToRouteInjectionToken } from "../../../../navigate-to-route-injection-token";
+
+const navigateToDaemonsetsInjectable = getInjectable({
+  id: "navigate-to-daemonsets",
+
+  instantiate: (di) => {
+    const navigateToRoute = di.inject(navigateToRouteInjectionToken);
+    const route = di.inject(daemonsetsRouteInjectable);
+
+    return () => navigateToRoute(route);
+  },
+});
+
+export default navigateToDaemonsetsInjectable;

packages/core/src/common/front-end-routing/routes/cluster/workloads/deployments/deployments-route.injectable.ts

@@ -0,0 +1,24 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import { shouldShowResourceInjectionToken } from "../../../../../cluster-store/allowed-resources-injection-token";
+import { frontEndRouteInjectionToken } from "../../../../front-end-route-injection-token";
+
+const deploymentsRouteInjectable = getInjectable({
+  id: "deployments-route",
+
+  instantiate: (di) => ({
+    path: "/deployments",
+    clusterFrame: true,
+    isEnabled: di.inject(shouldShowResourceInjectionToken, {
+      apiName: "deployments",
+      group: "apps",
+    }),
+  }),
+
+  injectionToken: frontEndRouteInjectionToken,
+});
+
+export default deploymentsRouteInjectable;

packages/core/src/common/front-end-routing/routes/cluster/workloads/deployments/navigate-to-deployments.injectable.ts

@@ -0,0 +1,20 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import deploymentsRouteInjectable from "./deployments-route.injectable";
+import { navigateToRouteInjectionToken } from "../../../../navigate-to-route-injection-token";
+
+const navigateToDeploymentsInjectable = getInjectable({
+  id: "navigate-to-deployments",
+
+  instantiate: (di) => {
+    const navigateToRoute = di.inject(navigateToRouteInjectionToken);
+    const route = di.inject(deploymentsRouteInjectable);
+
+    return () => navigateToRoute(route);
+  },
+});
+
+export default navigateToDeploymentsInjectable;

packages/core/src/common/front-end-routing/routes/cluster/workloads/jobs/jobs-route.injectable.ts

@@ -0,0 +1,24 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import { shouldShowResourceInjectionToken } from "../../../../../cluster-store/allowed-resources-injection-token";
+import { frontEndRouteInjectionToken } from "../../../../front-end-route-injection-token";
+
+const jobsRouteInjectable = getInjectable({
+  id: "jobs-route",
+
+  instantiate: (di) => ({
+    path: "/jobs",
+    clusterFrame: true,
+    isEnabled: di.inject(shouldShowResourceInjectionToken, {
+      apiName: "jobs",
+      group: "batch",
+    }),
+  }),
+
+  injectionToken: frontEndRouteInjectionToken,
+});
+
+export default jobsRouteInjectable;

packages/core/src/common/front-end-routing/routes/cluster/workloads/jobs/navigate-to-jobs.injectable.ts

@@ -0,0 +1,20 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import jobsRouteInjectable from "./jobs-route.injectable";
+import { navigateToRouteInjectionToken } from "../../../../navigate-to-route-injection-token";
+
+const navigateToJobsInjectable = getInjectable({
+  id: "navigate-to-jobs",
+
+  instantiate: (di) => {
+    const navigateToRoute = di.inject(navigateToRouteInjectionToken);
+    const route = di.inject(jobsRouteInjectable);
+
+    return () => navigateToRoute(route);
+  },
+});
+
+export default navigateToJobsInjectable;

packages/core/src/common/front-end-routing/routes/cluster/workloads/overview/navigate-to-workloads-overview.injectable.ts

@@ -0,0 +1,20 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import workloadsOverviewRouteInjectable from "./workloads-overview-route.injectable";
+import { navigateToRouteInjectionToken } from "../../../../navigate-to-route-injection-token";
+
+const navigateToWorkloadsOverviewInjectable = getInjectable({
+  id: "navigate-to-workloads-overview",
+
+  instantiate: (di) => {
+    const navigateToRoute = di.inject(navigateToRouteInjectionToken);
+    const route = di.inject(workloadsOverviewRouteInjectable);
+
+    return () => navigateToRoute(route);
+  },
+});
+
+export default navigateToWorkloadsOverviewInjectable;

packages/core/src/common/front-end-routing/routes/cluster/workloads/overview/workloads-overview-route.injectable.ts

@@ -0,0 +1,21 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import { computed } from "mobx";
+import { frontEndRouteInjectionToken } from "../../../../front-end-route-injection-token";
+
+const workloadsOverviewRouteInjectable = getInjectable({
+  id: "workloads-overview-route",
+
+  instantiate: () => ({
+    path: "/workloads",
+    clusterFrame: true,
+    isEnabled: computed(() => true),
+  }),
+
+  injectionToken: frontEndRouteInjectionToken,
+});
+
+export default workloadsOverviewRouteInjectable;

packages/core/src/common/front-end-routing/routes/cluster/workloads/pods/navigate-to-pods.injectable.ts

@@ -0,0 +1,20 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import podsRouteInjectable from "./pods-route.injectable";
+import { navigateToRouteInjectionToken } from "../../../../navigate-to-route-injection-token";
+
+const navigateToPodsInjectable = getInjectable({
+  id: "navigate-to-pods",
+
+  instantiate: (di) => {
+    const navigateToRoute = di.inject(navigateToRouteInjectionToken);
+    const route = di.inject(podsRouteInjectable);
+
+    return () => navigateToRoute(route);
+  },
+});
+
+export default navigateToPodsInjectable;

packages/core/src/common/front-end-routing/routes/cluster/workloads/pods/pods-route.injectable.ts

@@ -0,0 +1,24 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import { shouldShowResourceInjectionToken } from "../../../../../cluster-store/allowed-resources-injection-token";
+import { frontEndRouteInjectionToken } from "../../../../front-end-route-injection-token";
+
+const podsRouteInjectable = getInjectable({
+  id: "pods-route",
+
+  instantiate: (di) => ({
+    path: "/pods",
+    clusterFrame: true,
+    isEnabled: di.inject(shouldShowResourceInjectionToken, {
+      apiName: "pods",
+      group: "",
+    }),
+  }),
+
+  injectionToken: frontEndRouteInjectionToken,
+});
+
+export default podsRouteInjectable;

packages/core/src/common/front-end-routing/routes/cluster/workloads/replicasets/navigate-to-replicasets.injectable.ts

@@ -0,0 +1,20 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import replicasetsRouteInjectable from "./replicasets-route.injectable";
+import { navigateToRouteInjectionToken } from "../../../../navigate-to-route-injection-token";
+
+const navigateToReplicasetsInjectable = getInjectable({
+  id: "navigate-to-replicasets",
+
+  instantiate: (di) => {
+    const navigateToRoute = di.inject(navigateToRouteInjectionToken);
+    const route = di.inject(replicasetsRouteInjectable);
+
+    return () => navigateToRoute(route);
+  },
+});
+
+export default navigateToReplicasetsInjectable;

packages/core/src/common/front-end-routing/routes/cluster/workloads/replicasets/replicasets-route.injectable.ts

@@ -0,0 +1,24 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import { shouldShowResourceInjectionToken } from "../../../../../cluster-store/allowed-resources-injection-token";
+import { frontEndRouteInjectionToken } from "../../../../front-end-route-injection-token";
+
+const replicasetsRouteInjectable = getInjectable({
+  id: "replicasets-route",
+
+  instantiate: (di) => ({
+    path: "/replicasets",
+    clusterFrame: true,
+    isEnabled: di.inject(shouldShowResourceInjectionToken, {
+      apiName: "replicasets",
+      group: "apps",
+    }),
+  }),
+
+  injectionToken: frontEndRouteInjectionToken,
+});
+
+export default replicasetsRouteInjectable;

packages/core/src/common/front-end-routing/routes/cluster/workloads/statefulsets/navigate-to-statefulsets.injectable.ts

@@ -0,0 +1,20 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import statefulsetsRouteInjectable from "./statefulsets-route.injectable";
+import { navigateToRouteInjectionToken } from "../../../../navigate-to-route-injection-token";
+
+const navigateToStatefulsetsInjectable = getInjectable({
+  id: "navigate-to-statefulsets",
+
+  instantiate: (di) => {
+    const navigateToRoute = di.inject(navigateToRouteInjectionToken);
+    const route = di.inject(statefulsetsRouteInjectable);
+
+    return () => navigateToRoute(route);
+  },
+});
+
+export default navigateToStatefulsetsInjectable;

packages/core/src/common/front-end-routing/routes/cluster/workloads/statefulsets/statefulsets-route.injectable.ts

@@ -0,0 +1,24 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import { shouldShowResourceInjectionToken } from "../../../../../cluster-store/allowed-resources-injection-token";
+import { frontEndRouteInjectionToken } from "../../../../front-end-route-injection-token";
+
+const statefulsetsRouteInjectable = getInjectable({
+  id: "statefulsets-route",
+
+  instantiate: (di) => ({
+    path: "/statefulsets",
+    clusterFrame: true,
+    isEnabled: di.inject(shouldShowResourceInjectionToken, {
+      apiName: "statefulsets",
+      group: "apps",
+    }),
+  }),
+
+  injectionToken: frontEndRouteInjectionToken,
+});
+
+export default statefulsetsRouteInjectable;

packages/core/src/common/front-end-routing/routes/entity-settings/entity-settings-route.injectable.ts

@@ -0,0 +1,26 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import { computed } from "mobx";
+import type { Route } from "../../front-end-route-injection-token";
+import { frontEndRouteInjectionToken } from "../../front-end-route-injection-token";
+
+export interface EntitySettingsPathParameters {
+  entityId: string;
+}
+
+const entitySettingsRouteInjectable = getInjectable({
+  id: "entity-settings-route",
+
+  instantiate: (): Route<EntitySettingsPathParameters> => ({
+    path: "/entity/:entityId/settings",
+    clusterFrame: false,
+    isEnabled: computed(() => true),
+  }),
+
+  injectionToken: frontEndRouteInjectionToken,
+});
+
+export default entitySettingsRouteInjectable;

packages/core/src/common/front-end-routing/routes/entity-settings/navigate-to-entity-settings.injectable.ts

@@ -0,0 +1,23 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import entitySettingsRouteInjectable from "./entity-settings-route.injectable";
+import { navigateToRouteInjectionToken } from "../../navigate-to-route-injection-token";
+
+export type NavigateToEntitySettings = (entityId: string, targetTabId?: string) => void;
+
+const navigateToEntitySettingsInjectable = getInjectable({
+  id: "navigate-to-entity-settings",
+
+  instantiate: (di): NavigateToEntitySettings => {
+    const navigateToRoute = di.inject(navigateToRouteInjectionToken);
+    const route = di.inject(entitySettingsRouteInjectable);
+
+    return (entityId, targetTabId) =>
+      navigateToRoute(route, { parameters: { entityId }, fragment: targetTabId });
+  },
+});
+
+export default navigateToEntitySettingsInjectable;

packages/core/src/common/front-end-routing/routes/extensions/extensions-route.injectable.ts

@@ -0,0 +1,21 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import { computed } from "mobx";
+import { frontEndRouteInjectionToken } from "../../front-end-route-injection-token";
+
+const extensionsRouteInjectable = getInjectable({
+  id: "extensions-route",
+
+  instantiate: () => ({
+    path: "/extensions",
+    clusterFrame: false,
+    isEnabled: computed(() => true),
+  }),
+
+  injectionToken: frontEndRouteInjectionToken,
+});
+
+export default extensionsRouteInjectable;

packages/core/src/common/front-end-routing/routes/extensions/navigate-to-extensions.injectable.ts

@@ -0,0 +1,20 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import extensionsRouteInjectable from "./extensions-route.injectable";
+import { navigateToRouteInjectionToken } from "../../navigate-to-route-injection-token";
+
+const navigateToExtensionsInjectable = getInjectable({
+  id: "navigate-to-extensions",
+
+  instantiate: (di) => {
+    const navigateToRoute = di.inject(navigateToRouteInjectionToken);
+    const route = di.inject(extensionsRouteInjectable);
+
+    return () => navigateToRoute(route);
+  },
+});
+
+export default navigateToExtensionsInjectable;

packages/core/src/common/front-end-routing/routes/welcome/default-welcome-route.injectable.ts

@@ -0,0 +1,26 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import { computed } from "mobx";
+import welcomeRouteConfigInjectable from "./welcome-route-config.injectable";
+import { frontEndRouteInjectionToken } from "../../front-end-route-injection-token";
+
+const defaultWelcomeRouteInjectable = getInjectable({
+  id: "default-welcome-route",
+
+  instantiate: (di) => {
+    const welcomeRoute = di.inject(welcomeRouteConfigInjectable);
+
+    return {
+      path: "/welcome",
+      clusterFrame: false,
+      isEnabled: computed(() => welcomeRoute === "/welcome"),
+    };
+  },
+
+  injectionToken: frontEndRouteInjectionToken,
+});
+
+export default defaultWelcomeRouteInjectable;

packages/core/src/common/front-end-routing/routes/welcome/navigate-to-welcome.injectable.ts

@@ -0,0 +1,20 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import welcomeRouteInjectable from "./welcome-route.injectable";
+import { navigateToRouteInjectionToken } from "../../navigate-to-route-injection-token";
+
+const navigateToWelcomeInjectable = getInjectable({
+  id: "navigate-to-welcome",
+
+  instantiate: (di) => {
+    const navigateToRoute = di.inject(navigateToRouteInjectionToken);
+    const route = di.inject(welcomeRouteInjectable);
+
+    return () => navigateToRoute(route);
+  },
+});
+
+export default navigateToWelcomeInjectable;

packages/core/src/common/front-end-routing/routes/welcome/welcome-route-config.injectable.ts

@@ -0,0 +1,14 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import applicationInformationToken from "../../../vars/application-information-token";
+
+const welcomeRouteConfigInjectable = getInjectable({
+  id: "welcome-route-config",
+
+  instantiate: (di) => di.inject(applicationInformationToken).config.welcomeRoute,
+});
+
+export default welcomeRouteConfigInjectable;

packages/core/src/common/front-end-routing/routes/welcome/welcome-route.injectable.ts

@@ -0,0 +1,26 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import { computed } from "mobx";
+import welcomeRouteConfigInjectable from "./welcome-route-config.injectable";
+import { frontEndRouteInjectionToken } from "../../front-end-route-injection-token";
+
+const welcomeRouteInjectable = getInjectable({
+  id: "welcome-route",
+
+  instantiate: (di) => {
+    const welcomeRoute = di.inject(welcomeRouteConfigInjectable);
+
+    return {
+      path: welcomeRoute,
+      clusterFrame: false,
+      isEnabled: computed(() => true),
+    };
+  },
+
+  injectionToken: frontEndRouteInjectionToken,
+});
+
+export default welcomeRouteInjectable;