chore: Remove leading '+' on some directory names

Signed-off-by: Sebastian Malton <sebastian@malton.name>

packages/core/src/renderer/components/config-limit-ranges/index.ts

@@ -0,0 +1,7 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+
+export * from "./limit-ranges";
+export * from "./limit-range-details";

packages/core/src/renderer/components/config-limit-ranges/limit-range-details.scss

@@ -0,0 +1,17 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+
+.LimitRangeDetails {
+
+  .DrawerItem {
+    > .name {
+      font-weight: $font-weight-normal;
+      padding-left: 4px;
+    }
+    .DrawerItem {
+      padding-top: 4px;
+    }
+  }
+}

packages/core/src/renderer/components/config-limit-ranges/limit-range-details.tsx

@@ -0,0 +1,112 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+
+import "./limit-range-details.scss";
+
+import React from "react";
+import { observer } from "mobx-react";
+import type { KubeObjectDetailsProps } from "../kube-object-details";
+import type { LimitRangeItem } from "../../../common/k8s-api/endpoints/limit-range.api";
+import { LimitPart, LimitRange, Resource } from "../../../common/k8s-api/endpoints/limit-range.api";
+import { DrawerItem } from "../drawer/drawer-item";
+import { Badge } from "../badge";
+import type { Logger } from "../../../common/logger";
+import { withInjectables } from "@ogre-tools/injectable-react";
+import loggerInjectable from "../../../common/logger.injectable";
+
+export interface LimitRangeDetailsProps extends KubeObjectDetailsProps<LimitRange> {
+}
+
+function renderLimit(limit: LimitRangeItem, part: LimitPart, resource: Resource) {
+
+  const resourceLimit = limit[part]?.[resource];
+
+  if (!resourceLimit) {
+    return null;
+  }
+
+  return <Badge label={`${part}:${resourceLimit}`}/>;
+}
+
+function renderResourceLimits(limit: LimitRangeItem, resource: Resource) {
+  return (
+    <React.Fragment key={limit.type + resource}>
+      {renderLimit(limit, LimitPart.MIN, resource)}
+      {renderLimit(limit, LimitPart.MAX, resource)}
+      {renderLimit(limit, LimitPart.DEFAULT, resource)}
+      {renderLimit(limit, LimitPart.DEFAULT_REQUEST, resource)}
+      {renderLimit(limit, LimitPart.MAX_LIMIT_REQUEST_RATIO, resource)}
+    </React.Fragment>
+  );
+}
+
+function renderLimitDetails(limits: LimitRangeItem[], resources: Resource[]) {
+
+  return resources.map(resource => (
+    <DrawerItem key={resource} name={resource}>
+      {
+        limits.map(limit => renderResourceLimits(limit, resource))
+      }
+    </DrawerItem>
+  ));
+}
+
+interface Dependencies {
+  logger: Logger;
+}
+
+@observer
+class NonInjectedLimitRangeDetails extends React.Component<LimitRangeDetailsProps & Dependencies> {
+  render() {
+    const { object: limitRange, logger } = this.props;
+
+    if (!limitRange) {
+      return null;
+    }
+
+    if (!(limitRange instanceof LimitRange)) {
+      logger.error("[LimitRangeDetails]: passed object that is not an instanceof LimitRange", limitRange);
+
+      return null;
+    }
+
+    const containerLimits = limitRange.getContainerLimits();
+    const podLimits = limitRange.getPodLimits();
+    const pvcLimits = limitRange.getPVCLimits();
+
+    return (
+      <div className="LimitRangeDetails">
+        {containerLimits.length > 0 && (
+          <DrawerItem name="Container Limits" labelsOnly>
+            {
+              renderLimitDetails(containerLimits, [Resource.CPU, Resource.MEMORY, Resource.EPHEMERAL_STORAGE])
+            }
+          </DrawerItem>
+        )}
+        {podLimits.length > 0 && (
+          <DrawerItem name="Pod Limits" labelsOnly>
+            {
+              renderLimitDetails(podLimits, [Resource.CPU, Resource.MEMORY, Resource.EPHEMERAL_STORAGE])
+            }
+          </DrawerItem>
+        )}
+        {pvcLimits.length > 0 && (
+          <DrawerItem name="Persistent Volume Claim Limits" labelsOnly>
+            {
+              renderLimitDetails(pvcLimits, [Resource.STORAGE])
+            }
+          </DrawerItem>
+        )}
+      </div>
+    );
+  }
+}
+
+export const LimitRangeDetails = withInjectables<Dependencies, LimitRangeDetailsProps>(NonInjectedLimitRangeDetails, {
+  getProps: (di, props) => ({
+    ...props,
+    logger: di.inject(loggerInjectable),
+  }),
+});

packages/core/src/renderer/components/config-limit-ranges/limit-ranges-route-component.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 { LimitRanges } from "./limit-ranges";
+import limitRangesRouteInjectable from "../../../common/front-end-routing/routes/cluster/config/limit-ranges/limit-ranges-route.injectable";
+import { routeSpecificComponentInjectionToken } from "../../routes/route-specific-component-injection-token";
+
+const limitRangesRouteComponentInjectable = getInjectable({
+  id: "limit-ranges-route-component",
+
+  instantiate: (di) => ({
+    route: di.inject(limitRangesRouteInjectable),
+    Component: LimitRanges,
+  }),
+
+  injectionToken: routeSpecificComponentInjectionToken,
+});
+
+export default limitRangesRouteComponentInjectable;

packages/core/src/renderer/components/config-limit-ranges/limit-ranges-sidebar-items.injectable.tsx

@@ -0,0 +1,38 @@
+/**
+ * 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 limitRangesRouteInjectable from "../../../common/front-end-routing/routes/cluster/config/limit-ranges/limit-ranges-route.injectable";
+import { configSidebarItemId } from "../config/config-sidebar-items.injectable";
+import { sidebarItemsInjectionToken } from "../layout/sidebar-items.injectable";
+import routeIsActiveInjectable from "../../routes/route-is-active.injectable";
+import navigateToLimitRangesInjectable from "../../../common/front-end-routing/routes/cluster/config/limit-ranges/navigate-to-limit-ranges.injectable";
+
+const limitRangesSidebarItemsInjectable = getInjectable({
+  id: "limit-ranges-sidebar-items",
+
+  instantiate: (di) => {
+    const route = di.inject(limitRangesRouteInjectable);
+    const navigateToLimitRanges = di.inject(navigateToLimitRangesInjectable);
+    const routeIsActive = di.inject(routeIsActiveInjectable, route);
+
+    return computed(() => [
+      {
+        id: "limit-ranges",
+        parentId: configSidebarItemId,
+        title: "Limit Ranges",
+        onClick: navigateToLimitRanges,
+        isActive: routeIsActive,
+        isVisible: route.isEnabled,
+        orderNumber: 40,
+      },
+    ]);
+  },
+
+  injectionToken: sidebarItemsInjectionToken,
+});
+
+export default limitRangesSidebarItemsInjectable;

packages/core/src/renderer/components/config-limit-ranges/limit-ranges.scss

@@ -0,0 +1,16 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+
+.LimitRanges {
+  .TableCell {
+    &.warning {
+      @include table-cell-warning;
+    }
+  }
+
+  a.filterNamespace {
+    border-bottom: unset;
+  }
+}

packages/core/src/renderer/components/config-limit-ranges/limit-ranges.tsx

@@ -0,0 +1,75 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+
+import "./limit-ranges.scss";
+
+import { observer } from "mobx-react";
+import { KubeObjectListLayout } from "../kube-object-list-layout";
+import React from "react";
+import { KubeObjectStatusIcon } from "../kube-object-status-icon";
+import { SiblingsInTabLayout } from "../layout/siblings-in-tab-layout";
+import { KubeObjectAge } from "../kube-object/age";
+import type { LimitRangeStore } from "./store";
+import { withInjectables } from "@ogre-tools/injectable-react";
+import limitRangeStoreInjectable from "./store.injectable";
+import { NamespaceSelectBadge } from "../namespaces/namespace-select-badge";
+
+enum columnId {
+  name = "name",
+  namespace = "namespace",
+  age = "age",
+}
+
+interface Dependencies {
+  limitRangeStore: LimitRangeStore;
+}
+
+@observer
+class NonInjectedLimitRanges extends React.Component<Dependencies> {
+  render() {
+    return (
+      <SiblingsInTabLayout>
+        <KubeObjectListLayout
+          isConfigurable
+          tableId="configuration_limitranges"
+          className="LimitRanges"
+          store={this.props.limitRangeStore}
+          sortingCallbacks={{
+            [columnId.name]: limitRange => limitRange.getName(),
+            [columnId.namespace]: limitRange => limitRange.getNs(),
+            [columnId.age]: limitRange => -limitRange.getCreationTimestamp(),
+          }}
+          searchFilters={[
+            item => item.getName(),
+            item => item.getNs(),
+          ]}
+          renderHeaderTitle="Limit Ranges"
+          renderTableHeader={[
+            { title: "Name", className: "name", sortBy: columnId.name, id: columnId.name },
+            { className: "warning", showWithColumn: columnId.name },
+            { title: "Namespace", className: "namespace", sortBy: columnId.namespace, id: columnId.namespace },
+            { title: "Age", className: "age", sortBy: columnId.age, id: columnId.age },
+          ]}
+          renderTableContents={limitRange => [
+            limitRange.getName(),
+            <KubeObjectStatusIcon key="icon" object={limitRange}/>,
+            <NamespaceSelectBadge
+              key="namespace"
+              namespace={limitRange.getNs()}
+            />,
+            <KubeObjectAge key="age" object={limitRange} />,
+          ]}
+        />
+      </SiblingsInTabLayout>
+    );
+  }
+}
+
+export const LimitRanges = withInjectables<Dependencies>(NonInjectedLimitRanges, {
+  getProps: (di, props) => ({
+    ...props,
+    limitRangeStore: di.inject(limitRangeStoreInjectable),
+  }),
+});

packages/core/src/renderer/components/config-limit-ranges/store.injectable.ts

@@ -0,0 +1,29 @@
+/**
+ * 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 assert from "assert";
+import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manager/kube-object-store-token";
+import limitRangeApiInjectable from "../../../common/k8s-api/endpoints/limit-range.api.injectable";
+import loggerInjectable from "../../../common/logger.injectable";
+import clusterFrameContextForNamespacedResourcesInjectable from "../../cluster-frame-context/for-namespaced-resources.injectable";
+import storesAndApisCanBeCreatedInjectable from "../../stores-apis-can-be-created.injectable";
+import { LimitRangeStore } from "./store";
+
+const limitRangeStoreInjectable = getInjectable({
+  id: "limit-range-store",
+  instantiate: (di) => {
+    assert(di.inject(storesAndApisCanBeCreatedInjectable), "limitRangeStore is only available in certain environments");
+
+    const api = di.inject(limitRangeApiInjectable);
+
+    return new LimitRangeStore({
+      context: di.inject(clusterFrameContextForNamespacedResourcesInjectable),
+      logger: di.inject(loggerInjectable),
+    }, api);
+  },
+  injectionToken: kubeObjectStoreInjectionToken,
+});
+
+export default limitRangeStoreInjectable;

packages/core/src/renderer/components/config-limit-ranges/store.ts

@@ -0,0 +1,10 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+
+import { KubeObjectStore } from "../../../common/k8s-api/kube-object.store";
+import type { LimitRange, LimitRangeApi } from "../../../common/k8s-api/endpoints/limit-range.api";
+
+export class LimitRangeStore extends KubeObjectStore<LimitRange, LimitRangeApi> {
+}