@rancher/shell 3.0.12-rc.1 → 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
+  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';
 
 /**
@@ -25,6 +26,18 @@ export abstract class BasePluginProduct {
 
   protected addedResourceRoutes = false;
 
+  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[];
@@ -38,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 });
   }
 
   /**
@@ -68,6 +86,13 @@ export abstract class BasePluginProduct {
     }
   }
 
+  /**
+   * Generates data for group overview page routing
+   */
+  protected generateMetadataForGroupOverviewPageRouting(name: string, component: VueRouteComponent): OverviewPageRoutingMetadata {
+    return { name, component };
+  }
+
   /**
    * This is where we register the product and its children via the DSL
    */
@@ -97,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();
+    }
   }
 
   /**
@@ -115,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');
 
@@ -172,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;
@@ -187,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) {
@@ -198,16 +233,12 @@ export abstract class BasePluginProduct {
               defaultRoute = pluginProductsHelpers.generateVirtualTypeRoute(this.name, entryChild, { omitPath: true, extendProduct: !this.isNewProduct });
             }
           } else {
-            // Group with component - route to the group page itself
-            defaultRoute = pluginProductsHelpers.generateVirtualTypeRoute(this.name, undefined, {
-              omitPath: true, component: firstConfig.component, extendProduct: !this.isNewProduct
-            });
+            // Group with component - route to the group overview page (which will render the group's component and side-menu)
+            defaultRoute = pluginProductsHelpers.generateVirtualTypeRoute(this.name, this.generateMetadataForGroupOverviewPageRouting(firstConfig.name, firstConfig.component), { omitPath: true, extendProduct: !this.isNewProduct });
           }
         } else if (firstConfig.component) {
           // Group with component but no children - route to the group page itself
-          defaultRoute = pluginProductsHelpers.generateVirtualTypeRoute(this.name, undefined, {
-            omitPath: true, component: firstConfig.component, extendProduct: !this.isNewProduct
-          });
+          defaultRoute = pluginProductsHelpers.generateVirtualTypeRoute(this.name, this.generateMetadataForGroupOverviewPageRouting(firstConfig.name, firstConfig.component), { omitPath: true, extendProduct: !this.isNewProduct });
         }
       } else if (isProductChildWithType(firstConfig)) {
         // Simple configureType page (resource page)
@@ -236,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)) {
@@ -248,6 +335,14 @@ export abstract class BasePluginProduct {
       const name = `${ parentName }-${ item.name }`;
       const finalName = groupNaming ? `${ parentName }-${ groupNaming }-${ item.name }` : name;
 
+      // Check for duplicate page names within the same product
+      if (this.registeredPageNames.has(finalName)) {
+        this.surfaceError(`Duplicate page name "${ item.name }" - each page must have a unique name within a product`);
+      }
+
+      this.registeredPageNames.add(finalName);
+      this.pageIdMap.set(item.name, finalName);
+
       const virtualTypeConfig: VirtualTypeConfiguration = {
         label:      item.label,
         labelKey:   item.labelKey,
@@ -261,7 +356,8 @@ export abstract class BasePluginProduct {
       if (isProductChildGroup(item)) {
         virtualTypeConfig.exact = true;
         virtualTypeConfig.overview = true;
-        virtualTypeConfig.route = pluginProductsHelpers.generateVirtualTypeRoute(parentName, undefined, { extendProduct: !this.isNewProduct });
+        // Pass group metadata as pageChild so the route gets a unique path segment (e.g. /product/c/:cluster/groupName)
+        virtualTypeConfig.route = pluginProductsHelpers.generateVirtualTypeRoute(parentName, this.generateMetadataForGroupOverviewPageRouting(item.name, item.component as ProductChildCustomPage['component']), { extendProduct: !this.isNewProduct });
       } else {
         virtualTypeConfig.route = pluginProductsHelpers.generateVirtualTypeRoute(parentName, item, { extendProduct: !this.isNewProduct });
       }
@@ -270,6 +366,15 @@ export abstract class BasePluginProduct {
     } else if (isProductChildWithType(item)) {
       // Page with a "type" specified maps to a configureType
       const typeValue = item.type;
+
+      // Check for duplicate resource type within the same product
+      if (this.registeredPageNames.has(typeValue)) {
+        this.surfaceError(`Duplicate resource type "${ typeValue }" - each resource type must be unique within a product`);
+      }
+
+      this.registeredPageNames.add(typeValue);
+      this.pageIdMap.set(typeValue, typeValue);
+
       const route = pluginProductsHelpers.generateConfigureTypeRoute(parentName, item, { extendProduct: !this.isNewProduct });
 
       const configureTypeConfig: ConfigureTypeConfiguration = {
@@ -280,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) {
@@ -300,10 +421,6 @@ export abstract class BasePluginProduct {
           this.surfaceError('Group items cannot have a "type" property - only custom pages can have groups.');
         }
 
-        if (child.component && !this.isNewProduct) {
-          this.surfaceError('When extending an existing product, group parent items cannot have a component because of route matching conflicts.');
-        }
-
         let route;
 
         if (!child.component) {
@@ -316,7 +433,7 @@ export abstract class BasePluginProduct {
 
           route = pluginProductsHelpers.generateVirtualTypeRoute(parentName, pageForRoute, { extendProduct: !this.isNewProduct });
         } else {
-          route = pluginProductsHelpers.generateVirtualTypeRoute(parentName, undefined, { component: child.component, extendProduct: !this.isNewProduct });
+          route = pluginProductsHelpers.generateVirtualTypeRoute(parentName, this.generateMetadataForGroupOverviewPageRouting(child.name, child.component), { component: child.component, extendProduct: !this.isNewProduct });
         }
 
         // add the route for the group page/parent

package/core/plugin-products-helpers.ts

@@ -1,6 +1,7 @@
 import {
   RouteRecordRawWithParams, ProductChildGroup, ProductChild,
-  ProductChildCustomPage, ProductChildResourcePage, ProductRegistrationRouteGenerationOptions
+  ProductChildCustomPage, ProductChildResourcePage, ProductRegistrationRouteGenerationOptions,
+  OverviewPageRoutingMetadata
 } from '@shell/core/plugin-types';
 import { BLANK_CLUSTER } from '@shell/store/store-types';
 
@@ -62,7 +63,7 @@ class PluginProductsHelpers {
   }
 
   // VIRTUAL TYPE ROUTES
-  generateVirtualTypeRoute(parentName: string, pageChild: ProductChildCustomPage | undefined, options: ProductRegistrationRouteGenerationOptions = {}): RouteRecordRawWithParams {
+  generateVirtualTypeRoute(parentName: string, pageChild: ProductChildCustomPage | OverviewPageRoutingMetadata | undefined, options: ProductRegistrationRouteGenerationOptions = {}): RouteRecordRawWithParams {
     if (options.extendProduct) {
       return this.generateVirtualTypeRouteForExistingProduct(parentName, pageChild, options);
     } else {
@@ -71,7 +72,7 @@ class PluginProductsHelpers {
   }
 
   // VIRTUAL TYPE ROUTES - CLUSTER LEVEL EXTENSION
-  private generateVirtualTypeRouteForExistingProduct(parentName: string, pageChild: ProductChildCustomPage | undefined, options: ProductRegistrationRouteGenerationOptions = {}): RouteRecordRawWithParams {
+  private generateVirtualTypeRouteForExistingProduct(parentName: string, pageChild: ProductChildCustomPage | OverviewPageRoutingMetadata | undefined, options: ProductRegistrationRouteGenerationOptions = {}): RouteRecordRawWithParams {
     const { component, omitPath } = options;
     const name = pageChild ? `c-cluster-${ parentName }-${ pageChild.name }` : `c-cluster-${ parentName }`;
     const path = pageChild ? `c/:cluster/${ parentName }/${ pageChild.name }` : `c/:cluster/${ parentName }`;
@@ -95,7 +96,7 @@ class PluginProductsHelpers {
   }
 
   // VIRTUAL TYPE ROUTES - TOP LEVEL EXTENSION
-  private generateVirtualTypeRouteForNewProduct(parentName: string, pageChild: ProductChildCustomPage | undefined, options: ProductRegistrationRouteGenerationOptions = {}): RouteRecordRawWithParams {
+  private generateVirtualTypeRouteForNewProduct(parentName: string, pageChild: ProductChildCustomPage | OverviewPageRoutingMetadata | undefined, options: ProductRegistrationRouteGenerationOptions = {}): RouteRecordRawWithParams {
     const { component, omitPath } = options;
     const name = pageChild ? `${ parentName }-c-cluster-${ pageChild.name }` : `${ parentName }-c-cluster`;
     const path = pageChild ? `${ parentName }/c/:cluster/${ pageChild.name }` : `${ parentName }/c/:cluster`;

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>;
 
@@ -150,12 +150,27 @@ export type ConfigureTypeConfiguration = {
   //     ]
 }
 
+/**
+ * Represents a Vue component or an async function that resolves to a Vue component, used for route components in product configuration
+ */
+export type VueRouteComponent = RouteComponent | Async<RouteComponent>;
+
+/**
+ * Metadata for route generation to a product overview page
+ */
+export type OverviewPageRoutingMetadata = {
+  /** Name of the overview page */
+  name: string;
+  /** Component to render for the overview page */
+  component: VueRouteComponent;
+}
+
 /**
  * Represents a custom page with a component
  */
 export type ProductChildCustomPage = ProductChildMetadata & {
   /** Component to render for this custom page */
-  component: RouteComponent | Async<RouteComponent>;
+  component: VueRouteComponent;
   /** Optional configuration for the page */
   config?: VirtualTypeConfiguration;
 };
@@ -170,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[];
 };
 
 /**
@@ -189,7 +214,7 @@ export type ProductChild = ProductChildGroup | ProductChildPage; // eslint-disab
  * Represents a group of child pages in a product configuration
  */
 export type ProductChildGroup = ProductChildMetadata & {
-  component?: RouteComponent | Async<RouteComponent>;
+  component?: VueRouteComponent;
   children: ProductChild[];
   /** Default child to navigate to */
   default?: string;
@@ -203,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 */
@@ -218,5 +343,5 @@ export type ProductMetadata = Omit<ProductOptions, 'name' | 'label' | 'labelKey'
  */
 export type ProductSinglePage = ProductMetadata & {
   /** Component to render for this product (single page product) */
-  component: RouteComponent | Async<RouteComponent>;
+  component: VueRouteComponent;
 };

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