@rancher/shell 3.0.11 → 3.0.12-rc.1

package/store/__tests__/type-map.test.ts

@@ -7,6 +7,17 @@ import {
   SCHEMA,
 } from '@shell/config/types';
 
+// Type definitions for test data
+interface TestSchema {
+  id: string;
+  type: string;
+  attributes?: { kind: string };
+  _group?: string;
+  _id?: string;
+}
+
+type SchemaOrType = TestSchema | string;
+
 /**
  * types in the store
  */
@@ -115,9 +126,9 @@ describe('type-map', () => {
       /**
        * Stick in the required mode param to the expected menu items
        */
-      const setTypeMode = (modes, resourcesById) => {
-        return modes.reduce((res, mode) => {
-          const newResource = { };
+      const setTypeMode = (modes: string[], resourcesById: Record<string, any>) => {
+        return modes.reduce((res: Record<string, any>, mode: string) => {
+          const newResource: Record<string, any> = { };
 
           Object.entries(resourcesById).forEach(([id, resource]: [string, any]) => {
             newResource[id] = {
@@ -146,17 +157,17 @@ describe('type-map', () => {
             spoofedTypes: { [productName]: [] }
           },
           typeMapGetters: {
-            labelFor:          (schema, count) => '',
-            optionsFor:        (schema) => {},
+            labelFor:          (schema: SchemaOrType, count: number) => '',
+            optionsFor:        (schema: SchemaOrType) => ({}),
             groupForBasicType: () => {},
-            typeWeightFor:     (label, isBasic) => 1
+            typeWeightFor:     (label: string, isBasic: boolean) => 1
           },
           rootState:   {},
           rootGetters: {
             [`${ productStore }/all`]: (schema: string) => {
               return [];
             },
-            'prefs/get': (pref) => {},
+            'prefs/get': (pref: string) => {},
 
           },
 
@@ -201,9 +212,9 @@ describe('type-map', () => {
 
           const testTypeMapGetters = {
             ...typeMapGetters,
-            labelFor:          (schema, count) => 'Pod',
+            labelFor:          (schema: SchemaOrType, count: number) => 'Pod',
             groupForBasicType: () => true,
-            optionsFor:        (schema) => ({
+            optionsFor:        (schema: SchemaOrType) => ({
               namespaced:  true,
               customRoute: 'cde'
             }),
@@ -320,7 +331,7 @@ describe('type-map', () => {
 
             const testTypeMapGetters = {
               ...typeMapGetters,
-              groupForBasicType: (product, id) => false
+              groupForBasicType: (product: string, id: string) => false
             };
 
             const groups = getters.allTypes(state, testTypeMapGetters, rootState, rootGetters)(productName, modes);
@@ -473,7 +484,7 @@ describe('type-map', () => {
 
             const testTypeMapGetters = {
               ...typeMapGetters,
-              optionsFor: (schema) => ({
+              optionsFor: (schema: SchemaOrType) => ({
                 namespaced:       true,
                 customRoute:      'cde',
                 ifRancherCluster: true
@@ -497,7 +508,7 @@ describe('type-map', () => {
 
             const testTypeMapGetters = {
               ...typeMapGetters,
-              optionsFor: (schema) => ({
+              optionsFor: (schema: SchemaOrType) => ({
                 namespaced:       true,
                 customRoute:      'cde',
                 ifRancherCluster: false
@@ -521,7 +532,7 @@ describe('type-map', () => {
 
             const testTypeMapGetters = {
               ...typeMapGetters,
-              optionsFor: (schema) => ({
+              optionsFor: (schema: SchemaOrType) => ({
                 namespaced:       true,
                 customRoute:      'cde',
                 ifRancherCluster: true
@@ -545,7 +556,7 @@ describe('type-map', () => {
 
             const testTypeMapGetters = {
               ...typeMapGetters,
-              optionsFor: (schema) => ({
+              optionsFor: (schema: SchemaOrType) => ({
                 namespaced:  true,
                 customRoute: 'cde',
                 localOnly:   true
@@ -569,7 +580,7 @@ describe('type-map', () => {
 
             const testTypeMapGetters = {
               ...typeMapGetters,
-              optionsFor: (schema) => ({
+              optionsFor: (schema: SchemaOrType) => ({
                 namespaced:  true,
                 customRoute: 'cde',
                 localOnly:   true
@@ -630,9 +641,9 @@ describe('type-map', () => {
 
             const testTypeMapGetters = {
               ...typeMapGetters,
-              labelFor:          (schema, count) => 'Secret',
+              labelFor:          (schema: SchemaOrType, count: number) => 'Secret',
               groupForBasicType: () => true,
-              optionsFor:        (schema) => ({
+              optionsFor:        (schema: SchemaOrType) => ({
                 namespaced:  true,
                 customRoute: 'cde'
               }),
@@ -882,8 +893,10 @@ describe('type-map', () => {
 
             const testTypeMapGetters = {
               ...typeMapGetters,
-              labelFor: (schema, count) => {
-                switch (schema.id) {
+              labelFor: (schema: SchemaOrType, count: number) => {
+                const schemaId = typeof schema === 'object' ? schema.id : schema;
+
+                switch (schemaId) {
                 case 'secret':
                   return 'Secret';
                 default:
@@ -891,11 +904,11 @@ describe('type-map', () => {
                 }
               },
               groupForBasicType: () => true,
-              optionsFor:        (schema) => ({
+              optionsFor:        (schema: SchemaOrType) => ({
                 namespaced:  true,
                 customRoute: 'cde'
               }),
-              isFavorite: (id) => id === 'secret',
+              isFavorite: (id: string) => id === 'secret',
             };
 
             return {
@@ -1134,14 +1147,14 @@ describe('type-map', () => {
         },
       };
 
-      const createProductState = (products) => ({
+      const createProductState = (products: any) => ({
         products,
         schemaGeneration: 1,
       });
 
-      const createProductRootGetters = (moduleSchemas = [], moduleName = 'cluster') => ({
+      const createProductRootGetters = (moduleSchemas: any[] = [], moduleName = 'cluster') => ({
         'prefs/get':             () => false,
-        [`${ moduleName }/all`]: (resource) => {
+        [`${ moduleName }/all`]: (resource: any) => {
           if (resource === SCHEMA) {
             return moduleSchemas;
           }
@@ -1281,4 +1294,51 @@ describe('type-map', () => {
       });
     });
   });
+
+  describe('groupLabel', () => {
+    it('should return groupLabel when it exists in state', () => {
+      const state = { groupLabels: { mygroup: { label: 'My Group Label', labelKey: undefined } } };
+
+      const result = getters.groupLabel(state)('mygroup');
+
+      expect(result).toStrictEqual({ label: 'My Group Label', labelKey: undefined });
+    });
+
+    it('should return groupLabel with labelKey when set', () => {
+      const state = { groupLabels: { anothergroup: { label: undefined, labelKey: 'typeLabel.myKey' } } };
+
+      const result = getters.groupLabel(state)('anothergroup');
+
+      expect(result).toStrictEqual({ label: undefined, labelKey: 'typeLabel.myKey' });
+    });
+
+    it('should handle case-insensitive group names', () => {
+      const state = { groupLabels: { mygroup: { label: 'My Group', labelKey: undefined } } };
+
+      const result = getters.groupLabel(state)('MyGroup');
+
+      expect(result).toStrictEqual({ label: 'My Group', labelKey: undefined });
+    });
+
+    it('should return undefined when group label does not exist', () => {
+      const state = { groupLabels: {} };
+
+      const result = getters.groupLabel(state)('nonexistent');
+
+      expect(result).toBeUndefined();
+    });
+
+    it('should return undefined for empty, null, undefined, or non-existent group name', () => {
+      const state = { groupLabels: { mygroup: { label: 'My Group', labelKey: undefined } } };
+
+      // Empty string fails the groupName check and returns undefined
+      expect(getters.groupLabel(state)('')).toBeUndefined();
+      // null returns undefined
+      expect(getters.groupLabel(state)(null)).toBeUndefined();
+      // undefined returns undefined
+      expect(getters.groupLabel(state)(undefined)).toBeUndefined();
+      // Non-existent group returns undefined
+      expect(getters.groupLabel(state)('nonexistent')).toBeUndefined();
+    });
+  });
 });

package/store/type-map.js

@@ -317,6 +317,12 @@ export function DSL(store, product, module = 'type-map') {
       }
     },
 
+    labelGroup(group, label, labelKey) {
+      store.commit(`${ module }/labelGroup`, {
+        group, label, labelKey
+      });
+    },
+
     setGroupDefaultType(input, defaultType) {
       if ( isArray(input) ) {
         store.commit(`${ module }/setGroupDefaultType`, { groups: input, defaultType });
@@ -397,6 +403,7 @@ export const state = function() {
     groupIgnore:             [],
     groupWeights:            {},
     groupDefaultTypes:       {},
+    groupLabels:             {},
     basicGroupWeights:       { [ROOT]: 1000 },
     groupMappings:           [],
     typeIgnore:              [],
@@ -499,6 +506,23 @@ export const getters = {
     };
   },
 
+  groupLabel(state) {
+    return (group) => {
+      // Handle null/undefined
+      if (!group) {
+        return;
+      }
+
+      // commit is done with lowercase group names, so lowercase here to match
+      const groupName = group.toLowerCase();
+
+      // If this has been explicitly set, use that
+      if (groupName) {
+        return state.groupLabels[groupName];
+      }
+    };
+  },
+
   groupForBasicType(state) {
     return (product, schemaId) => {
       return state.basicTypes?.[product]?.[schemaId];
@@ -740,10 +764,21 @@ export const getters = {
 
         // Translate if an entry exists
         let label = name;
-        // i18n-uses nav.group.*
-        const key = `nav.group."${ name }"`;
+        let key;
+
+        // See if we have a configured label for this group
+        const groupLabel = getters['groupLabel'](name);
+
+        if (groupLabel?.label) {
+          label = groupLabel.label;
+        } else if (groupLabel?.labelKey) {
+          key = groupLabel.labelKey;
+        } else {
+          // i18n-uses nav.group.*
+          key = `nav.group."${ name }"`;
+        }
 
-        if ( rootGetters['i18n/exists'](key) ) {
+        if (key && rootGetters['i18n/exists'](key) ) {
           label = rootGetters['i18n/t'](key);
         }
 
@@ -1680,6 +1715,10 @@ export const mutations = {
     }
   },
 
+  labelGroup(state, { group, label, labelKey }) {
+    state.groupLabels[group.toLowerCase()] = { label, labelKey };
+  },
+
   // setGroupDefaultType({group: 'core', defaultType: 'name'});
   // By default when a group is clicked, the first item is selected - this allows
   // this behaviour to be changed and a named child type can be chosen

package/tsconfig.paths.json

@@ -14,6 +14,7 @@
         "../shell/pkg/*"
       ],
       "@components/*": [
+        "./rancher-components/*",
         "../pkg/rancher-components/src/components/*"
       ]
     },

package/types/resources/pod.ts

@@ -0,0 +1,18 @@
+/**
+ * Takes the contents of the POD restarts value `1 (2m47s ago)` and splits it into `1` and `2m47s ago`
+ */
+export const POD_RESTARTS_REG_EX = /^(\d+)\s*\(([^)]+)\)/;
+
+/**
+ * POD restarts value can be split into two (restart count and last restarted).
+ *
+ * This is a special path that Vai uses to sort/filter on the first part (restart count)
+ */
+export const POD_RESTART_FIELD = 'metadata.fields[3][0]';
+
+/**
+ * POD restarts value can be split into two (restart count and last restarted).
+ *
+ * This is a special path that Vai uses to sort/filter on the first part (last restarted)
+ */
+export const POD_LAST_RESTART_FIELD = 'metadata.fields[3][1]';