@rancher/shell 3.0.12-rc.2 → 3.0.12-rc.3

package/core/plugin-products-base.ts

@@ -2,7 +2,8 @@ import { IExtension } from '@shell/core/types';
 import {
   ProductChild, ProductMetadata,
   ConfigureTypeConfiguration, VirtualTypeConfiguration,
-  ProductChildCustomPage, VueRouteComponent, OverviewPageRoutingMetadata
+  ProductChildCustomPage, VueRouteComponent,
+  OverviewPageRoutingMetadata
 } from '@shell/core/plugin-types';
 import EmptyProductPage from '@shell/components/EmptyProductPage.vue';
 import pluginProductsHelpers from '@shell/core/plugin-products-helpers';
@@ -11,7 +12,7 @@ import {
   isProductChildWithComponent,
   isProductChildWithType,
   hasNameProperty,
-  hasTypeProperty
+  hasTypeProperty,
 } from '@shell/core/plugin-products-type-guards';
 
 /**
@@ -27,6 +28,16 @@ export abstract class BasePluginProduct {
 
   protected registeredPageNames: Set<string> = new Set();
 
+  // Maps user-friendly group name → internal resolved name (e.g. 'monitoring' → 'myapp-monitoring')
+  // Populated during processGroupRecursively, consumed by moveToGroup resolution in processProductLevelDSLOptions
+  protected groupNameMap: Map<string, string> = new Map();
+
+  // Maps user-facing page identifier → internal basicType key
+  // Resource pages: type → type (identity, e.g. 'pod' → 'pod')
+  // Custom pages: name → prefixed name (e.g. 'myPage' → 'product1-myPage')
+  // Populated during configurePageItem, consumed by moveToGroup resolution in processProductLevelDSLOptions
+  protected pageIdMap: Map<string, string> = new Map();
+
   protected DSLMethods: any;
 
   protected config: ProductChild[];
@@ -40,11 +51,16 @@ export abstract class BasePluginProduct {
    */
   abstract get isNewProduct(): boolean;
 
+  get productName(): string {
+    return this.name;
+  }
+
   /**
    * Helper to throw errors during product registration
    */
-  protected surfaceError(message: string): void {
-    throw new Error(`Extensions - product "${ this.name }" registration error ::: ${ message }`);
+  protected surfaceError(message: string, e?: any): never {
+    console.error(`Extensions - product "${ this.name }" registration error ::: ${ message }`); // eslint-disable-line no-console
+    throw new Error(`Extensions - product "${ this.name }" registration error ::: ${ message }`, { cause: e });
   }
 
   /**
@@ -106,6 +122,12 @@ export abstract class BasePluginProduct {
         this.processGroupRecursively(item, this.name);
       }
     });
+
+    // Process product-level DSL options after all groups are registered
+    // so that the groupNameMap is fully populated for moveToGroup resolution
+    if (this.product) {
+      this.processProductLevelDSLOptions();
+    }
   }
 
   /**
@@ -124,6 +146,10 @@ export abstract class BasePluginProduct {
     const itemGroup = item;
     const groupName = parentGroupName ? `${ productName }-${ parentGroupName }-${ itemGroup.name }` : `${ productName }-${ itemGroup.name }`;
 
+    // Map the user's friendly group name to the resolved internal name
+    // so that moveToGroup can translate friendly names automatically
+    this.groupNameMap.set(itemGroup.name, groupName);
+
     if (!Array.isArray(itemGroup.children)) {
       this.surfaceError('Children defined for group are not in an array format');
 
@@ -181,7 +207,7 @@ export abstract class BasePluginProduct {
   }
 
   /**
-   * Handles product registration via DSL
+   * Handles product registration via DSL (we also define entry route for the product here based on the config of the product - ordering)
    */
   protected handleProductRegistration(): void {
     const { basicType, product } = this.DSLMethods;
@@ -196,7 +222,7 @@ export abstract class BasePluginProduct {
 
       if (isProductChildGroup(firstConfig)) {
         // First config item is a group
-        if (firstConfig.children.length) {
+        if (firstConfig.children.length > 0) {
           const entryChild = firstConfig.children[0];
 
           if (!firstConfig.component) {
@@ -241,11 +267,67 @@ export abstract class BasePluginProduct {
     });
   }
 
+  /**
+   * Process product-level DSL options: renameGroups, ignoreGroups, moveToGroup.
+   * Called after all config items and groups are registered so that the groupNameMap is fully populated.
+   */
+  protected processProductLevelDSLOptions(): void {
+    const {
+      mapGroup, ignoreGroup, moveType, basicType
+    } = this.DSLMethods;
+
+    if (this.product?.renameGroups?.length) {
+      this.product.renameGroups.forEach((mapping) => {
+        mapGroup(mapping.groupSelector, mapping.newName);
+      });
+    }
+
+    if (this.product?.ignoreGroups?.length) {
+      this.product.ignoreGroups.forEach((ignore) => {
+        if (ignore.condition) {
+          ignoreGroup(ignore.groupSelector, ignore.condition);
+        } else {
+          ignoreGroup(ignore.groupSelector);
+        }
+      });
+    }
+
+    if (this.product?.moveToGroup?.length) {
+      this.product.moveToGroup.forEach((move) => {
+        const resolvedGroup = this.groupNameMap.get(move.groupName);
+
+        if (!resolvedGroup) {
+          this.surfaceError(`moveToGroup target group "${ move.groupName }" not found. Available groups: ${ Array.from(this.groupNameMap.keys()).join(', ') }`);
+        }
+
+        const resolvedPageId = this.pageIdMap.get(move.entryId);
+
+        if (!resolvedPageId) {
+          this.surfaceError(`moveToGroup entryId "${ move.entryId }" not found. Available pages: ${ Array.from(this.pageIdMap.keys()).join(', ') }`);
+        }
+
+        // Re-register via basicType to move the page in the nav tree (basic view mode)
+        basicType([resolvedPageId], resolvedGroup);
+
+        // Also register via moveType for non-basic view modes (e.g. "in use" mode).
+        // moveType uses regex matching against schema IDs, so it only works for resource types.
+        const isResourceType = resolvedPageId === move.entryId;
+
+        if (isResourceType) {
+          moveType(move.entryId, resolvedGroup, move.weight);
+        }
+      });
+    }
+  }
+
   /**
    * Configure virtualType (custom page) or configureType (resource page) for a page item
    */
   protected configurePageItem(parentName: string, item: ProductChild, groupNaming?: string): void {
-    const { configureType, virtualType, weightType } = this.DSLMethods;
+    const {
+      configureType, virtualType, weightType,
+      mapType, ignoreType, hideBulkActions, headers
+    } = this.DSLMethods;
 
     // Page with a "component" specified maps to a virtualType
     if (isProductChildWithComponent(item) || (isProductChildGroup(item) && item.component)) {
@@ -259,6 +341,7 @@ export abstract class BasePluginProduct {
       }
 
       this.registeredPageNames.add(finalName);
+      this.pageIdMap.set(item.name, finalName);
 
       const virtualTypeConfig: VirtualTypeConfiguration = {
         label:      item.label,
@@ -290,6 +373,7 @@ export abstract class BasePluginProduct {
       }
 
       this.registeredPageNames.add(typeValue);
+      this.pageIdMap.set(typeValue, typeValue);
 
       const route = pluginProductsHelpers.generateConfigureTypeRoute(parentName, item, { extendProduct: !this.isNewProduct });
 
@@ -301,6 +385,22 @@ export abstract class BasePluginProduct {
         customRoute: route
       };
 
+      if (item.headers || item.sspHeaders) {
+        headers(item.type, item.headers, item.sspHeaders);
+      }
+
+      if (item.overrideListResourceName) {
+        mapType(item.type, item.overrideListResourceName);
+      }
+
+      if (item.hideFromNav) {
+        ignoreType(item.type);
+      }
+
+      if (item.hideBulkActions) {
+        hideBulkActions(item.type, true);
+      }
+
       configureType(typeValue, { ...configureTypeConfig, ...(item.config || {}) });
 
       if (item.weight) {

package/core/plugin-products.ts

@@ -47,4 +47,8 @@ export class PluginProduct {
   get newProduct(): boolean {
     return this.instance.isNewProduct;
   }
+
+  get productName(): string {
+    return this.instance.productName;
+  }
 }

package/core/plugin-types.ts

@@ -4,7 +4,7 @@ import { NAME as EXPLORER_PROD_NAME } from '@shell/config/product/explorer.js';
 import { NAME as CLUSTER_MAN_PROD_NAME } from '@shell/config/product/manager.js';
 import { NAME as SETTINGS_PROD_NAME } from '@shell/config/product/settings.js';
 import { NAME as AUTH_PROD_NAME } from '@shell/config/product/auth.js';
-import { ProductOptions } from '@shell/core/types';
+import { ProductOptions, HeaderOptions, PaginationHeaderOptions } from '@shell/core/types';
 
 type Async<T> = () => Promise<T>;
 
@@ -185,6 +185,16 @@ export type ProductChildResourcePage = {
   config?: ConfigureTypeConfiguration;
   /** Ordering weight for this page among its siblings */
   weight?: number;
+  /** Use this to override the resource name used in the list view for this type */
+  overrideListResourceName?: string;
+  /** Whether to hide this resource from the side-menu entirely */
+  hideFromNav?: boolean;
+  /** Whether to hide bulk actions for this resource */
+  hideBulkActions?: boolean;
+  /** Table headers for this resource type (client-side pagination) */
+  headers?: HeaderOptions[];
+  /** Table headers for this resource type (server-side pagination) */
+  sspHeaders?: PaginationHeaderOptions[];
 };
 
 /**
@@ -218,6 +228,106 @@ export type ProductMetadata = Omit<ProductOptions, 'name' | 'label' | 'labelKey'
    * Product name (unique identifier)
    */
   name: string;
+  /**
+   * @internal
+   * Use `renameGroups` on the product metadata to remap group display names in the side-menu. Each entry matches a group's internal ID (via string or regex) and replaces its display label with a new name. This only changes how the group is labelled in the UI — it does not move resources between groups.
+   *
+   * The `groupSelector` is evaluated against group internal IDs. It can be an exact string or a `RegExp` pattern. The `newName` value is the new display name.
+   *
+   * const product: ProductMetadata = {
+   *   name:  'my-app',
+   *   label: 'My App',
+   *   renameGroups: [
+   *     // Rename a group with an ugly internal ID to a friendlier display name
+   *     { groupSelector: 'cert-manager.io', newName: 'Certificates' },
+   *     // Use a regex to rename all groups matching a pattern
+   *     { groupSelector: /^networking\./, newName: 'Networking' },
+   *   ],
+   * };
+   */
+  renameGroups?: {
+    /** String or regex to match against group internal IDs */
+    groupSelector: RegExp | string;
+    /** Display name to use for matching groups */
+    newName: string;
+  }[];
+  /**
+   * @internal
+   *
+   * Use `moveToGroup` on the product metadata to move pages (resource types or custom pages) into specific side-menu groups. This is useful when a page should appear inside a group but isn't defined as a child of that group in the config.
+   * Each entry identifies a page by its `entryId` — the resource `type` string or the custom page `name` — and moves it into the specified group. Use the group's `name` as you defined it in your config.
+   *
+   * const monitoringGroup: ProductChildGroup = {
+   *   name:     'monitoring',
+   *   label:    'Monitoring',
+   *   children: [
+   *    { name: 'alerts', label: 'Alerts', component: () => import('./pages/Alerts.vue') },
+   *   ],
+   * };
+
+   * const dashboardPage: ProductChildCustomPage = {
+   *   name: 'dashboard', label: 'Dashboard', component: () => import('./pages/Dashboard.vue'),
+   * };
+
+   * const product: ProductMetadata = {
+   *   name:        'my-app',
+   *   label:       'My App',
+   *   moveToGroup: [
+   *    // Move the 'pod' resource type into the 'monitoring' group
+   *    { entryId: 'pod', groupName: 'monitoring' },
+   *    // Move a custom page into the 'monitoring' group
+   *    { entryId: 'dashboard', groupName: 'monitoring' },
+   *   ],
+   * };
+   *
+   * extension.addProduct(product, [monitoringGroup, { type: 'pod' }, dashboardPage]);
+   *
+   * Note: The `entryId` must match a page declared in the same product config — either a resource page's `type` or a custom page's `name`. The target `groupName` must be a `ProductChildGroup` defined in the same config. If either is not found, an error is thrown at registration time listing the available options. Only exact string identifiers are supported (no regex).
+   *
+   * The optional `weight` parameter controls precedence when multiple `moveToGroup` rules target the same page (default: `5`). Higher weight takes precedence.
+  */
+  moveToGroup?: {
+    /** Page identifier — the resource `type` string or the custom page `name` */
+    entryId: string;
+    /** Target group name as defined in your group config (`name` property) */
+    groupName: string;
+    /** Ordering weight for the mapping (default: 5). Higher weight takes precedence when multiple rules match */
+    weight?: number;
+  }[];
+  /**
+   * @internal
+   *
+   * maps to DSL ignoreGroup
+   *
+   * Use `ignoreGroups` on the product metadata to hide specific side-menu groups. Each entry specifies a `groupSelector` to match group names — either an exact string or a regex pattern.
+   *
+   * The `condition` callback is optional. When provided, it receives the store getters and returns `true` to hide the group (conditional hide). When omitted, the group is always hidden (unconditional hide).
+   *
+   * Example usage:
+   * const product: ProductMetadata = {
+   *   name:  'my-app',
+   *   label: 'My App',
+   *   ignoreGroups: [
+   *     // Always hide the "internal" group (unconditional — no condition)
+   *     { groupSelector: 'internal' },
+   *     // Hide all groups matching a regex pattern (unconditional)
+   *     { groupSelector: /^deprecated/ },
+   *     // Conditionally hide based on a feature flag
+   *     {
+   *       groupSelector: 'experimental',
+   *       condition:     (getters) => !getters['features/isEnabled']('experimental-feature'),
+   *     },
+   *   ],
+   * };
+   *
+   *
+   * In this example, the "internal" group is always hidden, any group with a name starting with "deprecated-" is hidden, and the "experimental" group is hidden unless the "experimental-feature" flag is enabled in the store.
+   */
+  ignoreGroups?: {
+    /** String or regex to match against group names */
+    groupSelector: string | RegExp;
+    /** Optional conditional function that accepts the root Dashboard Vuex store getters and returns true if the group should be ignored */
+    condition?: (getters: any) => boolean }[];
 } & (
   /** Human-readable label for the product
    * Either label or labelKey are required */

package/core/plugin.ts

@@ -135,21 +135,29 @@ export class Plugin implements IPlugin {
   }
 
   addProduct(product: ProductFunction | ProductMetadata | ProductSinglePage | string, config?: ProductChild[]): void {
+    let pluginProduct: PluginProduct;
+
     if (typeof product === 'string') {
-      this.productConfigs.push(PluginProduct.fromName(this, product));
+      pluginProduct = PluginProduct.fromName(this, product);
     } else if (product?.name) {
       if (!config) {
-        const p = product as ProductSinglePage;
-
-        this.productConfigs.push(new PluginProduct(this, p, []));
+        pluginProduct = new PluginProduct(this, product as ProductSinglePage, []);
       } else {
-        const p = product as ProductMetadata;
-
-        this.productConfigs.push(new PluginProduct(this, p, config));
+        pluginProduct = new PluginProduct(this, product as ProductMetadata, config);
       }
     } else {
       this.products.push(product as ProductFunction);
+
+      return;
     }
+
+    const existingProduct = this.productConfigs.find((p) => p.newProduct && p.productName === pluginProduct.productName);
+
+    if (existingProduct) {
+      throw new Error(`Extensions - product "${ pluginProduct.productName }" registration error ::: addProduct can only be called once per product. Use extendProduct to add pages to an existing product.`);
+    }
+
+    this.productConfigs.push(pluginProduct);
   }
 
   extendProduct(product: StandardProductName | string, config: ProductChild[] | ProductChild): void {

package/core/productDebugger.js

@@ -21,8 +21,13 @@ export function DSLRegistrationsPerProduct(store, prodName) {
     }
 
     // prod configureType
-    if (dataType === 'typeOptions' && typeMapData[dataType].filter((item) => item.customRoute && item.customRoute.name.includes(prodName))) {
-      parsedData['configureType'] = typeMapData[dataType].filter((item) => item.customRoute && item.customRoute.name.includes(prodName));
+    if (dataType === 'typeOptions') {
+      const allTypeOptions = Object.values(typeMapData[dataType]).flat();
+      const filtered = allTypeOptions.filter((item) => item.customRoute && item.customRoute.name.includes(prodName));
+
+      if (filtered.length > 0) {
+        parsedData['configureType'] = filtered;
+      }
     }
 
     // other types which map with prodName
@@ -36,7 +41,7 @@ export function DSLRegistrationsPerProduct(store, prodName) {
     }
   });
 
-  console.error('*** PRODUCT DATA DEBUGGER **** DSLRegistrationsPerProduct', parsedData); // eslint-disable-line no-console
+  console.error(`*** PRODUCT DATA DEBUGGER ${ prodName } **** DSLRegistrationsPerProduct`, parsedData); // eslint-disable-line no-console
 }
 
 export function registeredRoutes(store, prodName) {
@@ -44,5 +49,5 @@ export function registeredRoutes(store, prodName) {
 
   const parsedData = routes.filter((route) => route.path.includes(prodName));
 
-  console.error('*** PRODUCT DATA DEBUGGER **** registeredRoutes', parsedData); // eslint-disable-line no-console
+  console.error(`*** PRODUCT DATA DEBUGGER ${ prodName } **** registeredRoutes`, parsedData); // eslint-disable-line no-console
 }

package/core/types-provisioning.ts

@@ -86,6 +86,48 @@ export interface ClusterProvisionerContext {
   isView: boolean
 }
 
+/**
+ * Existing tabs to show or hide in the cluster's detail view
+ */
+export interface ClusterProvisionerDetailTabs {
+  /**
+   * CAPI machine pool tab
+   */
+  machines: boolean,
+  /**
+   * Mgmt node pool tab
+   */
+  nodes?: boolean,
+  /**
+   * RKE2 provisioning logs
+   */
+  logs: boolean,
+  /**
+   * RKE2 registration commands
+   */
+  registration: boolean,
+  /**
+   * RKE2 snapshots
+   */
+  snapshots: boolean,
+  /**
+   * Kube resources related to the instance of provisioning.cattle.io.cluster
+   */
+  related: boolean,
+  /**
+   * Kube events associated with the instance of provisioning.cattle.io.cluster
+   */
+  events: boolean,
+  /**
+   * Kube conditions of the provisioning.cattle.io.cluster instance
+   */
+  conditions: boolean,
+  /**
+   * RKE2 autoscaler
+   */
+  autoscaler?: boolean,
+}
+
 /**
  * Interface that a custom Cluster Provisioner should implement
  *
@@ -180,36 +222,7 @@ export interface IClusterProvisioner {
    *
    * `plugin.addTab(TabLocation.RESOURCE_DETAIL... ` can be used to add additional tabs to the same view
    */
-  detailTabs: {
-    /**
-     * RKE2 machine pool tabs
-     */
-    machines: boolean,
-    /**
-     * RKE2 provisioning logs
-     */
-    logs: boolean,
-    /**
-     * RKE2 registration commands
-     */
-    registration: boolean,
-    /**
-     * RKE2 snapshots
-     */
-    snapshots: boolean,
-    /**
-     * Kube resources related to the instance of provisioning.cattle.io.cluster
-     */
-    related: boolean,
-    /**
-     * Kube events associated with the instance of provisioning.cattle.io.cluster
-     */
-    events: boolean,
-    /**
-     * Kube conditions of the provisioning.cattle.io.cluster instance
-     */
-    conditions: boolean
-  };
+  detailTabs: ClusterProvisionerDetailTabs;
 
   /* --------------------------------------------------------------------------------------
    * Getters / Functions for Managing Machine Configs

package/core/types.ts

@@ -4,8 +4,9 @@ import type { ExtensionManager } from '@shell/types/extension-manager';
 import { PaginationSettingsStores } from '@shell/types/resources/settings';
 import type {
   ProductMetadata, ProductSinglePage,
-  StandardProductName, RouteRecordRawWithParams, ProductChildGroup,
-  ProductChildPage, ProductChild
+  StandardProductName, RouteRecordRawWithParams, ProductChild,
+  ProductChildGroup,
+  ProductChildPage
 } from './plugin-types';
 
 // Cluster Provisioning types
@@ -552,7 +553,7 @@ export interface DSLReturnType {
    * @param headers {@link HeaderOptions[]}
    * @returns {@link void}
    */
-  headers: (type: string, headers: HeaderOptions[]) => void;
+  headers: (type: string, headers?: HeaderOptions[], paginationHeaders?: PaginationHeaderOptions[]) => void;
 
   /**
    * Create and register a new product
@@ -562,12 +563,30 @@ export interface DSLReturnType {
   product: (options: ProductOptions) => void;
 
   /**
-   * Create and label a group. The group will show up in navigation
-   * @param groupNane Name of the group
-   * @param label Label in navigation
+   /**
+   * Remap group display names in the side-menu navigation.
+   *
+   * Each entry matches a group's internal ID (via string or regex) and replaces its display label
+   * with a new name. This only changes how the group is labelled in the UI — it does not move
+   * resources between groups.
+   *
+   * @param match String, string for a regex or a regex object to match against group names
+   * @param replace Replacement string or function for the display name
+   * @param weight Priority for applying this mapping (higher numbers applied first, default 5)
+   * @param continueOnMatch If true, continue matching other rules after this one matches
+   * @returns {@link void}
+   */
+  mapGroup: (match: string | RegExp, replace: string | Function, weight?: number, continueOnMatch?: boolean) => void;
+
+  /**
+   * Remap a type ID to a display name
+   * @param match String, string for a regex or a regex object to match against type IDs
+   * @param replace Replacement string or function for the display name
+   * @param weight Priority for applying this mapping (higher numbers applied first, default 5)
+   * @param continueOnMatch If true, continue matching other rules after this one matches
    * @returns {@link void}
    */
-  mapGroup: (groupName: string, label: string) => void;
+  mapType: (match: string | RegExp, replace: string | Function, weight?: number, continueOnMatch?: boolean) => void;
 
   /**
    * Create and configure a myriad of options for a type
@@ -595,18 +614,36 @@ export interface DSLReturnType {
   weightType: (input: string, weight: number, forBasic: boolean) => void;
 
   /**
-   * Leaving these here for completeness but I don't think these should be advertised as useable to plugin creators.
+   * Never show the specified type in the navigation
+   * @param regexOrString String, string for a regex or a regex object to match against type names
+   * @returns {@link void}
+   */
+  ignoreType: (regexOrString: string | RegExp) => void;
+
+  /**
+   * Never show the specified group or any types in it
+   * @param regexOrString String, string for a regex or a regex object to match against group names
+   * @param fn Conditional function that accepts getters and returns true if the group should be ignored
+   * @returns {@link void}
    */
-  // componentForType: (type: string, replacementType: string)
-  // groupBy: (type: string, field: string)
-  // hideBulkActions: (type: string, field)
-  // ignoreGroup: (regexOrString)
-  // ignoreType: (regexOrString)
-  //
-  // mapType: (match, replace)
-  // moveType: (match, group)
-  // setGroupDefaultType: (input, defaultType)
-  // spoofedType: (obj)
+  ignoreGroup: (regexOrString: string | RegExp, fn?: (getters: any) => boolean) => void;
+
+  /**
+   * Move a resource type into a different navigation group
+   * @param match String or regex to match against resource type names
+   * @param group Target group name to move the matched types into
+   * @param weight Ordering weight for the mapping (default: 5)
+   * @returns {@link void}
+   */
+  moveType: (match: string | RegExp, group: string, weight?: number) => void;
+
+  /**
+   * Control visibility of bulk actions (e.g. delete) in the list view toolbar for a specific resource type
+   * @param type The resource type to configure
+   * @param hide Whether to hide bulk actions. Set to `true` to hide them
+   * @returns {@link void}
+   */
+  hideBulkActions: (type: string, hide: boolean) => void;
 
   labelGroup: (group: string, label: string | undefined, labelKey?: string) => void;
 
@@ -663,8 +700,8 @@ export interface IExtension {
    * @param name
    * @param config
    */
-  addProduct(product: ProductMetadata, config: ProductChildGroup[]): void;
   addProduct(product: ProductMetadata, config: ProductChildPage[]): void;
+  addProduct(product: ProductMetadata, config: ProductChildGroup[]): void;
   addProduct(product: ProductMetadata, config: ProductChild[]): void;
 
   /**
@@ -694,8 +731,8 @@ export interface IExtension {
    * @param product Product to be extended
    * @param config Product extension configuration
    */
-  extendProduct(product: StandardProductName | string, config: ProductChildGroup[]): void;
   extendProduct(product: StandardProductName | string, config: ProductChildPage[]): void;
+  extendProduct(product: StandardProductName | string, config: ProductChildGroup[]): void;
   extendProduct(product: StandardProductName | string, config: ProductChild[]): void;
 
   /**

package/detail/__tests__/pod.test.ts

@@ -0,0 +1,41 @@
+import podDetail from '@shell/detail/pod.vue';
+
+const { containers } = podDetail.computed;
+
+describe('view: pod', () => {
+  it('should not use 2x icon sizing in init container column', () => {
+    const initContainer = { name: 'init', image: 'init:latest' };
+    const appContainer = { name: 'app', image: 'app:latest' };
+
+    const rows = containers.call({
+      allContainers: [appContainer, initContainer],
+      allStatuses:   [{
+        name:      'app',
+        ready:     true,
+        state:     {},
+        lastState: {}
+      }, {
+        name:      'init',
+        ready:     false,
+        state:     {},
+        lastState: {}
+      }],
+      dateTimeFormat: () => '',
+      t:              () => '',
+      value:          {
+        containerActions:      [],
+        containerIsInit:       (container: { name: string }) => container.name === 'init',
+        containerStateColor:   () => 'text-success',
+        containerStateDisplay: () => 'running',
+        openLogs:              jest.fn(),
+        openShell:             jest.fn(),
+      },
+    });
+
+    const initRow = rows.find((row: { name: string }) => row.name === 'init');
+    const appRow = rows.find((row: { name: string }) => row.name === 'app');
+
+    expect(initRow.initIcon).toBe('icon-checkmark text-success ml-5');
+    expect(appRow.initIcon).toBe('icon-minus text-muted ml-5');
+  });
+});