@rancher/shell 3.0.8-rc.8 → 3.0.8-rc.9

package/components/auth/SelectPrincipal.vue

@@ -56,11 +56,13 @@ export default {
 
   data() {
     return {
-      principals:     null,
-      searchStr:      '',
-      options:        [],
-      newValue:       '',
-      tooltipContent: null,
+      principals:        null,
+      searchStr:         '',
+      options:           [],
+      newValue:          '',
+      tooltipContent:    null,
+      hasSearchTooShort: false,
+      minSearchLength:   2,
     };
   },
 
@@ -133,9 +135,20 @@ export default {
       this.searchStr = str;
 
       if ( str ) {
+        // Backend requires minimum 2 characters for search
+        if (str.length < this.minSearchLength) {
+          this.hasSearchTooShort = true;
+          this.options = [];
+          loading(false);
+
+          return;
+        }
+
+        this.hasSearchTooShort = false;
         loading(true);
         this.debouncedSearch(str, loading);
       } else {
+        this.hasSearchTooShort = false;
         this.search(null, loading);
       }
     },
@@ -196,7 +209,12 @@ export default {
     @on-close="setTooltipContent()"
   >
     <template v-slot:no-options="{ searching }">
-      <template v-if="searching">
+      <template v-if="hasSearchTooShort">
+        <span class="search-slot">
+          {{ t('cluster.memberRoles.addClusterMember.minCharacters', { count: minSearchLength }) }}
+        </span>
+      </template>
+      <template v-else-if="searching">
         <span class="search-slot">
           {{ t('cluster.memberRoles.addClusterMember.noResults') }}
         </span>

package/components/auth/__tests__/SelectPrincipal.test.ts

@@ -0,0 +1,119 @@
+import { shallowMount, type VueWrapper } from '@vue/test-utils';
+import SelectPrincipal from '@shell/components/auth/SelectPrincipal.vue';
+
+describe('component: SelectPrincipal', () => {
+  const mockStore = { dispatch: jest.fn().mockResolvedValue([]) };
+
+  const defaultMountOptions = {
+    global: {
+      mocks: {
+        $fetchState: { pending: false },
+        $store:      mockStore,
+        t:           (key: string, opts?: any) => opts?.count ? `${ key } ${ opts.count }` : key,
+      },
+      stubs: {
+        LabeledSelect: {
+          template: '<div class="labeled-select-stub"><slot name="no-options" :searching="searching" /></div>',
+          props:    ['options', 'searchable', 'filterable'],
+          data() {
+            return { searching: false };
+          }
+        },
+        Principal: true,
+      },
+    },
+  };
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    mockStore.dispatch.mockResolvedValue([]);
+  });
+
+  describe('onSearch', () => {
+    it('should set hasSearchTooShort to true when search string is less than minSearchLength', async() => {
+      const wrapper: VueWrapper<any> = shallowMount(SelectPrincipal, defaultMountOptions);
+
+      // Set principals to an empty array to avoid null errors
+      wrapper.vm.principals = [];
+      await wrapper.vm.$nextTick();
+
+      const loadingFn = jest.fn();
+
+      wrapper.vm.onSearch('a', loadingFn);
+
+      expect(wrapper.vm.hasSearchTooShort).toBe(true);
+      expect(wrapper.vm.options).toStrictEqual([]);
+      expect(loadingFn).toHaveBeenCalledWith(false);
+    });
+
+    it('should set hasSearchTooShort to false when search string meets minSearchLength', async() => {
+      const wrapper: VueWrapper<any> = shallowMount(SelectPrincipal, defaultMountOptions);
+
+      wrapper.vm.principals = [];
+      await wrapper.vm.$nextTick();
+
+      const loadingFn = jest.fn();
+
+      wrapper.vm.onSearch('ab', loadingFn);
+
+      expect(wrapper.vm.hasSearchTooShort).toBe(false);
+      expect(loadingFn).toHaveBeenCalledWith(true);
+    });
+
+    it('should set hasSearchTooShort to false when search string is empty', async() => {
+      const wrapper: VueWrapper<any> = shallowMount(SelectPrincipal, defaultMountOptions);
+
+      wrapper.vm.principals = [];
+      await wrapper.vm.$nextTick();
+
+      // First set hasSearchTooShort to true
+      wrapper.vm.hasSearchTooShort = true;
+
+      const loadingFn = jest.fn();
+
+      wrapper.vm.onSearch('', loadingFn);
+
+      expect(wrapper.vm.hasSearchTooShort).toBe(false);
+    });
+
+    it('should not call debouncedSearch when search string is too short', async() => {
+      const wrapper: VueWrapper<any> = shallowMount(SelectPrincipal, defaultMountOptions);
+
+      wrapper.vm.principals = [];
+      await wrapper.vm.$nextTick();
+
+      // Spy on the debounced search
+      const debouncedSearchSpy = jest.spyOn(wrapper.vm, 'debouncedSearch');
+      const loadingFn = jest.fn();
+
+      wrapper.vm.onSearch('x', loadingFn);
+
+      expect(debouncedSearchSpy).not.toHaveBeenCalled();
+    });
+
+    it('should call debouncedSearch when search string meets minimum length', async() => {
+      const wrapper: VueWrapper<any> = shallowMount(SelectPrincipal, defaultMountOptions);
+
+      wrapper.vm.principals = [];
+      await wrapper.vm.$nextTick();
+
+      const debouncedSearchSpy = jest.spyOn(wrapper.vm, 'debouncedSearch');
+      const loadingFn = jest.fn();
+
+      wrapper.vm.onSearch('xy', loadingFn);
+
+      expect(debouncedSearchSpy).toHaveBeenCalledWith('xy', loadingFn);
+    });
+  });
+
+  describe('minSearchLength', () => {
+    it('should have a default minSearchLength of 2', async() => {
+      const wrapper: VueWrapper<any> = shallowMount(SelectPrincipal, defaultMountOptions);
+
+      wrapper.vm.principals = [];
+      await wrapper.vm.$nextTick();
+
+      expect(wrapper.vm.minSearchLength).toBe(2);
+    });
+  });
+});

package/components/formatter/InternalExternalIP.vue

@@ -108,10 +108,13 @@ export default {
     >
       <template #default>
         <RcStatusBadge
-          v-clean-tooltip="tooltipContent"
+          v-clean-tooltip="{content: tooltipContent, triggers: ['hover', 'focus']}"
+          :aria-label="t('generic.plusMore', {n: remainingIpCount})"
+          tabindex="0"
           status="info"
           data-testid="plus-more"
           @click.stop
+          @keyup.enter.space="$refs.dropdown.show()"
         >
           {{ t('generic.plusMore', {n: remainingIpCount}) }}
         </RcStatusBadge>

package/components/formatter/__tests__/InternalExternalIP.test.ts

@@ -24,7 +24,7 @@ describe('component: InternalExternalIP', () => {
         components: { 'v-dropdown': { name: 'v-dropdown', template: '<div><slot /><slot name="popper" /></div>' } },
         directives: {
           'clean-tooltip': (el, binding) => {
-            el.setAttribute('v-clean-tooltip', binding.value);
+            el.setAttribute('v-clean-tooltip', binding.value.content);
           }
         },
         mocks: { $store: { getters: mockGetters } }

package/components/templates/standalone.vue

@@ -3,7 +3,7 @@
 </template>
 
 <style lang="scss">
-body, #__nuxt, #__layout {
+body, #__root, #__layout {
   height: 100%;
 }
 </style>

package/composables/useI18n.ts

@@ -11,7 +11,16 @@ let store: Store<any> | null = null;
  * @returns A translated string or the raw value if the raw parameter is set to true.
  */
 const t = (key: string, args?: unknown, raw?: boolean): string => {
-  return stringFor(store, key, args, raw);
+  if (!store) {
+    if (!!process.env.dev) {
+      // eslint-disable-next-line no-console
+      console.warn('useI18n: store not available');
+    }
+
+    return key;
+  }
+
+  return stringFor(store, key, args as any, raw);
 };
 
 export type I18n = { t: typeof t };

package/config/__test__/uiplugins.test.ts

@@ -0,0 +1,309 @@
+import {
+  UI_PLUGIN_ANNOTATION,
+  UI_PLUGIN_CHART_ANNOTATIONS,
+  EXTENSIONS_INCOMPATIBILITY_TYPES,
+  isUIPlugin,
+  uiPluginHasAnnotation,
+  parseRancherVersion,
+  // shouldNotLoadPlugin, this is required per test so that we can mock semver.coerce
+  isSupportedChartVersion,
+  isChartVersionHigher
+} from '@shell/config/uiplugins';
+
+import * as VersionModule from '@shell/config/version';
+
+let semver;
+let originalCoerce: any;
+const MOCK_API_VERSION = '33.33.33';
+
+describe('uiPlugins Config methods', () => {
+  describe('fx: isUIPlugin', () => {
+    const pluginChart = { versions: [{ annotations: { [UI_PLUGIN_ANNOTATION.NAME]: UI_PLUGIN_ANNOTATION.VALUE } }, { annotations: {} }] };
+
+    it('should return true if any version has the UI plugin annotation', () => {
+      expect(isUIPlugin(pluginChart)).toBe(true);
+    });
+    it('should return false if chart is null/undefined', () => {
+      expect(isUIPlugin(null)).toBe(false);
+    });
+  });
+
+  describe('fx: uiPluginHasAnnotation', () => {
+    const version1 = { annotations: { [UI_PLUGIN_ANNOTATION.NAME]: UI_PLUGIN_ANNOTATION.VALUE } };
+    const chart = { versions: [version1] };
+
+    it('should return true if it finds version with annotation and its corresponding value', () => {
+      expect(uiPluginHasAnnotation(chart, UI_PLUGIN_ANNOTATION.NAME, UI_PLUGIN_ANNOTATION.VALUE)).toBe(true);
+    });
+    it('should return false if chart has no version with a given pair of annotation/value', () => {
+      expect(uiPluginHasAnnotation(chart, 'bananas', UI_PLUGIN_ANNOTATION.VALUE)).toBe(false);
+    });
+  });
+
+  describe('fx: parseRancherVersion', () => {
+    it('should handle standard version strings', () => {
+      expect(parseRancherVersion('v2.8.1')).toBe('2.8.1');
+    });
+    it('should apply .999 patch for RC versions', () => {
+      expect(parseRancherVersion('v2.8.1-rc1')).toBe('2.8.999');
+    });
+    it('should apply .999 patch for "head" versions', () => {
+      expect(parseRancherVersion('2.8.0-head')).toBe('2.8.999');
+    });
+  });
+
+  const PLUGIN_NAME = 'test-plugin';
+
+  const basePluginResource = {
+    name:     PLUGIN_NAME,
+    version:  '1.0.0',
+    endpoint: '/some/path',
+    metadata: { [UI_PLUGIN_CHART_ANNOTATIONS.EXTENSIONS_VERSION]: '>=1.0.0' }
+  };
+  const compatibleEnv = {
+    rancherVersion: '2.7.5',
+    kubeVersion:    'v1.25.10',
+  };
+
+  describe('fx: shouldNotLoadPlugin', () => {
+    beforeEach(() => {
+      jest.resetModules();
+      process.env.UI_EXTENSIONS_API_VERSION = MOCK_API_VERSION;
+
+      semver = require('semver');
+      originalCoerce = semver.coerce;
+
+      jest.spyOn(semver, 'coerce').mockImplementation((v) => {
+        if (v === MOCK_API_VERSION) {
+          return { version: '3.0.0' };
+        }
+
+        // Use the original for all other inputs (Rancher, Kube)
+        return originalCoerce(v);
+      });
+    });
+
+    afterEach(() => {
+      jest.restoreAllMocks();
+    });
+
+    it('should return false when compatible', () => {
+      const { shouldNotLoadPlugin } = require('./../uiplugins');
+
+      expect(shouldNotLoadPlugin(basePluginResource, compatibleEnv, [])).toBe(false);
+    });
+
+    it('should return "plugins.error.api" if Extensions API version is incompatible', () => {
+      const { shouldNotLoadPlugin } = require('./../uiplugins');
+
+      const incompatibleApiPlugin = {
+        ...basePluginResource,
+        metadata: { [UI_PLUGIN_CHART_ANNOTATIONS.EXTENSIONS_VERSION]: '>=4.0.0' }
+      };
+
+      expect(shouldNotLoadPlugin(incompatibleApiPlugin, compatibleEnv, [])).toBe('plugins.error.api');
+    });
+
+    it('should return "plugins.error.primeOnly" if extension is Prime-only and Rancher is not Prime', () => {
+      const { shouldNotLoadPlugin } = require('./../uiplugins');
+
+      jest.spyOn(VersionModule, 'isRancherPrime').mockReturnValue(false);
+
+      const incompatibleApiPlugin = {
+        ...basePluginResource,
+        metadata: {
+          [UI_PLUGIN_CHART_ANNOTATIONS.EXTENSIONS_VERSION]: '>=1.0.0',
+          [UI_PLUGIN_CHART_ANNOTATIONS.PRIME_ONLY]:         'true'
+        }
+      };
+
+      expect(shouldNotLoadPlugin(incompatibleApiPlugin, compatibleEnv, [])).toBe('plugins.error.primeOnly');
+    });
+
+    it('should return "plugins.error.host" if HOST application value is incompatible', () => {
+      const { shouldNotLoadPlugin } = require('./../uiplugins');
+
+      const incompatibleApiPlugin = {
+        ...basePluginResource,
+        metadata: {
+          [UI_PLUGIN_CHART_ANNOTATIONS.EXTENSIONS_VERSION]: '>=1.0.0',
+          [UI_PLUGIN_CHART_ANNOTATIONS.EXTENSIONS_HOST]:    'rancher-dummy-host'
+        }
+      };
+
+      expect(shouldNotLoadPlugin(incompatibleApiPlugin, compatibleEnv, [])).toBe('plugins.error.host');
+    });
+
+    it('should return "plugins.error.kubeVersion" if incompatible', () => {
+      const { shouldNotLoadPlugin } = require('./../uiplugins');
+
+      const incompatibleApiPlugin = {
+        ...basePluginResource,
+        metadata: {
+          [UI_PLUGIN_CHART_ANNOTATIONS.EXTENSIONS_VERSION]: '>=1.0.0',
+          [UI_PLUGIN_CHART_ANNOTATIONS.KUBE_VERSION]:       '>= 2.0.0'
+        }
+      };
+
+      expect(shouldNotLoadPlugin(incompatibleApiPlugin, compatibleEnv, [])).toBe('plugins.error.kubeVersion');
+    });
+
+    it('should return "plugins.error.version" if incompatible', () => {
+      const { shouldNotLoadPlugin } = require('./../uiplugins');
+
+      const incompatibleApiPlugin = {
+        ...basePluginResource,
+        metadata: {
+          [UI_PLUGIN_CHART_ANNOTATIONS.EXTENSIONS_VERSION]: '>=1.0.0',
+          [UI_PLUGIN_CHART_ANNOTATIONS.RANCHER_VERSION]:    '>= 3.0.0'
+        }
+      };
+
+      expect(shouldNotLoadPlugin(incompatibleApiPlugin, compatibleEnv, [])).toBe('plugins.error.version');
+    });
+
+    it('should return "plugins.error.developerPkg" if a builtin extension with the same name was loaded first', () => {
+      const { shouldNotLoadPlugin } = require('./../uiplugins');
+
+      const incompatibleApiPlugin = {
+        ...basePluginResource,
+        metadata: { [UI_PLUGIN_CHART_ANNOTATIONS.EXTENSIONS_VERSION]: '>=1.0.0' }
+      };
+
+      expect(shouldNotLoadPlugin(incompatibleApiPlugin, compatibleEnv, [{ name: PLUGIN_NAME, builtin: true }])).toBe('plugins.error.developerPkg');
+    });
+  });
+
+  describe('fx: isSupportedChartVersion', () => {
+    beforeEach(() => {
+      jest.resetModules();
+      process.env.UI_EXTENSIONS_API_VERSION = MOCK_API_VERSION;
+
+      semver = require('semver');
+      originalCoerce = semver.coerce;
+
+      jest.spyOn(semver, 'coerce').mockImplementation((v) => {
+        if (v === MOCK_API_VERSION) {
+          return { version: '3.0.0' };
+        }
+
+        // Use the original for all other inputs (Rancher, Kube)
+        return originalCoerce(v);
+      });
+    });
+
+    afterEach(() => {
+      jest.restoreAllMocks();
+    });
+
+    const versionData = {
+      rancherVersion: 'v2.7.5',
+      kubeVersion:    'v1.25.10',
+      version:        '1.0.0'
+    };
+
+    it('should return "isVersionCompatible" true when compatible', () => {
+      const { isSupportedChartVersion } = require('./../uiplugins');
+
+      const annotations = {
+        [UI_PLUGIN_CHART_ANNOTATIONS.KUBE_VERSION]:       '>=1.0.0',
+        [UI_PLUGIN_CHART_ANNOTATIONS.RANCHER_VERSION]:    '>=2.0.0',
+        [UI_PLUGIN_CHART_ANNOTATIONS.EXTENSIONS_VERSION]: '>=2.0.0'
+      };
+      const data = { ...versionData, version: { annotations } };
+      const result = isSupportedChartVersion(data, true);
+
+      expect(result.isVersionCompatible).toBe(true);
+      expect(result.versionIncompatibilityData).toStrictEqual({});
+    });
+
+    it('should return incompatibility object for kube version mismatch', () => {
+      const annotations = { [UI_PLUGIN_CHART_ANNOTATIONS.KUBE_VERSION]: '>=2.0.0' };
+      const data = { ...versionData, version: { annotations } };
+      const result = isSupportedChartVersion(data, true);
+
+      expect(result.isVersionCompatible).toBe(false);
+      expect(result.versionIncompatibilityData.type).toBe(EXTENSIONS_INCOMPATIBILITY_TYPES.KUBE);
+      expect(result.versionIncompatibilityData.required).toBe('>=2.0.0');
+    });
+
+    it('should return incompatibility object for Rancher version mismatch', () => {
+      const annotations = { [UI_PLUGIN_CHART_ANNOTATIONS.RANCHER_VERSION]: '>=3.0.0' };
+      const data = { ...versionData, version: { annotations } };
+      const result = isSupportedChartVersion(data, true);
+
+      expect(result.isVersionCompatible).toBe(false);
+      expect(result.versionIncompatibilityData.type).toBe(EXTENSIONS_INCOMPATIBILITY_TYPES.UI);
+      expect(result.versionIncompatibilityData.required).toBe('>=3.0.0');
+    });
+
+    it('should return incompatibility object for UI version mismatch', () => {
+      const annotations = { [UI_PLUGIN_CHART_ANNOTATIONS.UI_VERSION]: '>=3.0.0' };
+      const data = { ...versionData, version: { annotations } };
+      const result = isSupportedChartVersion(data, true);
+
+      expect(result.isVersionCompatible).toBe(false);
+      expect(result.versionIncompatibilityData.type).toBe(EXTENSIONS_INCOMPATIBILITY_TYPES.UI);
+      expect(result.versionIncompatibilityData.required).toBe('>=3.0.0');
+    });
+
+    it('should return incompatibility object for extensions api missing', () => {
+      const annotations = {};
+      const data = { ...versionData, version: { annotations } };
+      const result = isSupportedChartVersion(data, true);
+
+      expect(result.isVersionCompatible).toBe(false);
+      expect(result.versionIncompatibilityData.type).toBe(EXTENSIONS_INCOMPATIBILITY_TYPES.EXTENSIONS_API_MISSING);
+      expect(result.versionIncompatibilityData.required).toBeUndefined();
+    });
+
+    it('should return incompatibility object for extensions API version mismatch', () => {
+      const { isSupportedChartVersion } = require('./../uiplugins');
+
+      const annotations = { [UI_PLUGIN_CHART_ANNOTATIONS.EXTENSIONS_VERSION]: '>=4.0.0' };
+      const data = { ...versionData, version: { annotations } };
+      const result = isSupportedChartVersion(data, true);
+
+      expect(result.isVersionCompatible).toBe(false);
+      expect(result.versionIncompatibilityData.type).toBe(EXTENSIONS_INCOMPATIBILITY_TYPES.EXTENSIONS_API);
+      expect(result.versionIncompatibilityData.required).toBe('>=4.0.0');
+    });
+
+    it('should return incompatibility object for HOST_APP mismatch', () => {
+      const { isSupportedChartVersion } = require('./../uiplugins');
+
+      const annotations = { [UI_PLUGIN_CHART_ANNOTATIONS.EXTENSIONS_VERSION]: '>=1.0.0 < 5.0.0', [UI_PLUGIN_CHART_ANNOTATIONS.EXTENSIONS_HOST]: 'rancher-dummy-host' };
+      const data = { ...versionData, version: { annotations } };
+      const result = isSupportedChartVersion(data, true);
+
+      expect(result.isVersionCompatible).toBe(false);
+      expect(result.versionIncompatibilityData.type).toBe(EXTENSIONS_INCOMPATIBILITY_TYPES.HOST);
+      expect(result.versionIncompatibilityData.required).toBe('rancher-dummy-host');
+    });
+
+    it('should return incompatibility object for Prime only extension running in non-prime env', () => {
+      const { isSupportedChartVersion } = require('./../uiplugins');
+
+      jest.spyOn(VersionModule, 'isRancherPrime').mockReturnValue(false);
+
+      const annotations = { [UI_PLUGIN_CHART_ANNOTATIONS.EXTENSIONS_VERSION]: '>=1.0.0 < 5.0.0', [UI_PLUGIN_CHART_ANNOTATIONS.PRIME_ONLY]: 'true' };
+      const data = { ...versionData, version: { annotations } };
+      const result = isSupportedChartVersion(data, true);
+
+      expect(result.isVersionCompatible).toBe(false);
+      expect(result.versionIncompatibilityData.type).toBe(EXTENSIONS_INCOMPATIBILITY_TYPES.PRIME_ONLY);
+      expect(result.versionIncompatibilityData.required).toBe(true);
+    });
+  });
+
+  describe('fx: isChartVersionHigher', () => {
+    // Tests now rely on the actual semver.gt implementation
+    it('should return true when version A is higher', () => {
+      expect(isChartVersionHigher('2.1.0', '2.0.0')).toBe(true);
+    });
+    it('should return false when version A is lower or equal', () => {
+      expect(isChartVersionHigher('2.0.0', '2.1.0')).toBe(false);
+      expect(isChartVersionHigher('2.0.0', '2.0.0')).toBe(false);
+    });
+  });
+});

package/config/labels-annotations.js

@@ -85,6 +85,7 @@ export const CATALOG = {
   _PARTNER:  'partner',
   _OTHER:    'other',
 
+  PRIME_ONLY:   'catalog.cattle.io/prime-only',
   EXPERIMENTAL: 'catalog.cattle.io/experimental',
   NAMESPACE:    'catalog.cattle.io/namespace',
   RELEASE_NAME: 'catalog.cattle.io/release-name',

package/config/product/explorer.js

@@ -180,7 +180,8 @@ export function init(store) {
   mapGroup(/^(.*\.)?(scc)\.cattle\.io$/, 'SCC');
 
   const dePaginateBindings = configureConditionalDepaginate({ maxResourceCount: 5000 });
-  const dePaginateNormanBindings = configureConditionalDepaginate({ maxResourceCount: 5000, isNorman: true }) ;
+  const dePaginateNormanBindings = configureConditionalDepaginate({ maxResourceCount: 5000, isNorman: true });
+  const dePaginateNormanUsers = configureConditionalDepaginate({ maxResourceCount: 5000, isNorman: true });
 
   configureType(NODE, { isCreatable: false, isEditable: true });
   configureType(WORKLOAD_TYPES.JOB, { isEditable: false, match: WORKLOAD_TYPES.JOB });
@@ -189,6 +190,7 @@ export function init(store) {
   configureType(MANAGEMENT.PROJECT, { displayName: store.getters['i18n/t']('namespace.project.label') });
   configureType(NORMAN.CLUSTER_ROLE_TEMPLATE_BINDING, { depaginate: dePaginateNormanBindings });
   configureType(NORMAN.PROJECT_ROLE_TEMPLATE_BINDING, { depaginate: dePaginateNormanBindings });
+  configureType(NORMAN.USER, { depaginate: dePaginateNormanUsers });
   configureType(SNAPSHOT, { depaginate: true });
 
   configureType(SECRET, { showListMasthead: false });

package/config/router/routes.js

@@ -81,9 +81,13 @@ export default [
       {
         path:      '/c/:cluster/uiplugins',
         name:      'c-cluster-uiplugins',
-        component: () => interopDefault(import('@shell/pages/c/_cluster/uiplugins/index.vue')),
+        component: () => interopDefault(import('@shell/pages/c/_cluster/uiplugins/index.vue'))
+      },
+      {
+        path:      '/c/:cluster/uiplugins/catalogs',
+        component: () => interopDefault(import('@shell/pages/c/_cluster/uiplugins/catalogs.vue')),
+        name:      'c-cluster-uiplugins-catalogs'
       },
-
       {
         path:      '/diagnostic',
         component: () => interopDefault(import('@shell/pages/diagnostic.vue')),

package/config/types.js

@@ -222,6 +222,13 @@ export const MANAGEMENT = {
   OIDC_CLIENT:                   'management.cattle.io.oidcclient'
 };
 
+export const BRAND = {
+  SUSE:    'suse',
+  CSP:     'csp',
+  FEDERAL: 'federal',
+  RGS:     'rgs',
+};
+
 export const EXT = { USER_ACTIVITY: 'ext.cattle.io.useractivity' };
 
 export const CAPI = {